@malloy-publisher/server 0.0.197 → 0.0.198-dev1

package/dist/server.mjs

@@ -44,6 +44,7 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js
@@ -115087,6 +115088,91 @@ var require_winston = __commonJS((exports) => {
   warn.forProperties(exports, "deprecated", ["emitErrs", "levelLength"]);
 });
 
+// src/logger.ts
+function extractTraceIdFromTraceparent(traceparent) {
+  if (!traceparent) {
+    return;
+  }
+  const parts = traceparent.split("-");
+  const traceId = parts.length >= 2 ? parts[1] : parts.length == 1 ? parts[0] : undefined;
+  if (traceId && traceId.length === 32 && /^[0-9a-fA-F]{32}$/.test(traceId)) {
+    return traceId;
+  }
+  return;
+}
+function formatDuration(durationMs) {
+  if (durationMs >= 1000) {
+    const seconds = durationMs / 1000;
+    return `${seconds.toFixed(2)}s`;
+  }
+  return `${durationMs.toFixed(2)}ms`;
+}
+var import_winston, isTelemetryEnabled, VALID_LOG_LEVELS, getLogLevel = () => {
+  if (process.env.LOG_LEVEL) {
+    const logLevel = process.env.LOG_LEVEL.toLowerCase();
+    if (VALID_LOG_LEVELS.includes(logLevel)) {
+      return logLevel;
+    } else {
+      console.error(`Invalid log level: ${process.env.LOG_LEVEL}. Valid log levels are: ${VALID_LOG_LEVELS.join(", ")}. Defaulting to "debug".`);
+    }
+  }
+  return "debug";
+}, logger, DISABLE_RESPONSE_LOGGING, loggerMiddleware = (req, res, next) => {
+  const startTime = performance.now();
+  const resJson = res.json;
+  res.json = (body) => {
+    res.locals.body = body;
+    return resJson.call(res, body);
+  };
+  res.on("finish", () => {
+    const endTime = performance.now();
+    const durationMs = endTime - startTime;
+    const traceparent = req.headers["traceparent"];
+    const traceId = extractTraceIdFromTraceparent(traceparent);
+    const logMetadata = {
+      statusCode: res.statusCode,
+      duration: formatDuration(durationMs),
+      payload: req.body,
+      params: req.params,
+      query: req.query
+    };
+    if (!DISABLE_RESPONSE_LOGGING) {
+      logMetadata.response = res.locals.body;
+    }
+    if (traceId) {
+      logMetadata.traceId = traceId;
+    }
+    if (req.url !== "/metrics" && req.url !== "/health" && req.url !== "/health/liveness" && req.url !== "/health/readiness") {
+      logger.info(`${req.method} ${req.url}`, logMetadata);
+    }
+  });
+  next();
+}, logAxiosError = (error) => {
+  if (error.response) {
+    logger.error("Axios server-side error", {
+      url: error.response.config.url,
+      status: error.response.status,
+      headers: error.response.headers,
+      data: error.response.data
+    });
+  } else if (error.request) {
+    logger.error("Axios client-side error", { error: error.request });
+  } else {
+    logger.error("Axios unknown error", { error });
+  }
+};
+var init_logger = __esm(() => {
+  import_winston = __toESM(require_winston(), 1);
+  isTelemetryEnabled = Boolean(process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
+  VALID_LOG_LEVELS = ["error", "warn", "info", "verbose", "debug", "silly"];
+  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.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]
+  });
+  DISABLE_RESPONSE_LOGGING = process.env.DISABLE_RESPONSE_LOGGING === "true" || process.env.DISABLE_RESPONSE_LOGGING === "1";
+});
+
 // ../../node_modules/bytes/index.js
 var require_bytes = __commonJS((exports, module) => {
   /*!
@@ -147228,6 +147314,132 @@ var require_dist4 = __commonJS((exports) => {
   __exportStar(require_legacy2(), exports);
 });
 
+// src/constants.ts
+import os from "os";
+var API_PREFIX = "/api/v0", README_NAME = "README.md", PUBLISHER_CONFIG_NAME = "publisher.config.json", PACKAGE_MANIFEST_NAME = "publisher.json", MODEL_FILE_SUFFIX = ".malloy", NOTEBOOK_FILE_SUFFIX = ".malloynb", ROW_LIMIT = 1000, TEMP_DIR_PATH, PUBLISHER_DATA_DIR = "publisher_data";
+var init_constants = __esm(() => {
+  TEMP_DIR_PATH = os.tmpdir();
+});
+
+// src/errors.ts
+import { MalloyError } from "@malloydata/malloy";
+function internalErrorToHttpError(error) {
+  if (error instanceof BadRequestError) {
+    return httpError(400, error.message);
+  } else if (error instanceof FrozenConfigError) {
+    return httpError(403, error.message);
+  } else if (error instanceof EnvironmentNotFoundError) {
+    return httpError(404, error.message);
+  } else if (error instanceof PackageNotFoundError) {
+    return httpError(404, error.message);
+  } else if (error instanceof ModelNotFoundError) {
+    return httpError(404, error.message);
+  } else if (error instanceof MalloyError) {
+    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) {
+    return httpError(502, error.message);
+  } else if (error instanceof MaterializationNotFoundError) {
+    return httpError(404, error.message);
+  } else if (error instanceof MaterializationConflictError) {
+    return httpError(409, error.message);
+  } else if (error instanceof InvalidStateTransitionError) {
+    return httpError(409, error.message);
+  } else if (error instanceof ServiceUnavailableError) {
+    return httpError(503, error.message);
+  } else {
+    return httpError(500, error.message);
+  }
+}
+function httpError(code, message) {
+  return {
+    status: code,
+    json: {
+      code,
+      message
+    }
+  };
+}
+var NotImplementedError, BadRequestError, EnvironmentNotFoundError, PackageNotFoundError, ModelNotFoundError, ConnectionNotFoundError, ConnectionError, ConnectionAuthError, ModelCompilationError, FrozenConfigError, MaterializationNotFoundError, MaterializationConflictError, InvalidStateTransitionError, ServiceUnavailableError;
+var init_errors = __esm(() => {
+  init_constants();
+  NotImplementedError = class NotImplementedError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  BadRequestError = class BadRequestError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  EnvironmentNotFoundError = class EnvironmentNotFoundError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  PackageNotFoundError = class PackageNotFoundError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ModelNotFoundError = class ModelNotFoundError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ConnectionNotFoundError = class ConnectionNotFoundError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ConnectionError = class ConnectionError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ConnectionAuthError = class ConnectionAuthError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ModelCompilationError = class ModelCompilationError extends Error {
+    constructor(error) {
+      super(error.message);
+    }
+  };
+  FrozenConfigError = class FrozenConfigError extends Error {
+    constructor(message = `Publisher config can't be updated when ${PUBLISHER_CONFIG_NAME} has { "frozenConfig": true }`) {
+      super(message);
+    }
+  };
+  MaterializationNotFoundError = class MaterializationNotFoundError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  MaterializationConflictError = class MaterializationConflictError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  InvalidStateTransitionError = class InvalidStateTransitionError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+  ServiceUnavailableError = class ServiceUnavailableError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  };
+});
+
 // ../../node_modules/delayed-stream/lib/delayed_stream.js
 var require_delayed_stream = __commonJS((exports, module) => {
   var Stream = __require("stream").Stream;
@@ -196989,26 +197201,26 @@ var require_utils74 = __commonJS((exports, module) => {
     }
     mkdirSync(folder);
   };
-  Utils.prototype.writeFileTo = function(path4, content, overwrite, attr) {
+  Utils.prototype.writeFileTo = function(path3, content, overwrite, attr) {
     const self2 = this;
-    if (self2.fs.existsSync(path4)) {
+    if (self2.fs.existsSync(path3)) {
       if (!overwrite)
         return false;
-      var stat4 = self2.fs.statSync(path4);
+      var stat4 = self2.fs.statSync(path3);
       if (stat4.isDirectory()) {
         return false;
       }
     }
-    var folder = pth.dirname(path4);
+    var folder = pth.dirname(path3);
     if (!self2.fs.existsSync(folder)) {
       self2.makeDir(folder);
     }
     var fd;
     try {
-      fd = self2.fs.openSync(path4, "w", 438);
+      fd = self2.fs.openSync(path3, "w", 438);
     } catch (e) {
-      self2.fs.chmodSync(path4, 438);
-      fd = self2.fs.openSync(path4, "w", 438);
+      self2.fs.chmodSync(path3, 438);
+      fd = self2.fs.openSync(path3, "w", 438);
     }
     if (fd) {
       try {
@@ -197017,33 +197229,33 @@ var require_utils74 = __commonJS((exports, module) => {
         self2.fs.closeSync(fd);
       }
     }
-    self2.fs.chmodSync(path4, attr || 438);
+    self2.fs.chmodSync(path3, attr || 438);
     return true;
   };
-  Utils.prototype.writeFileToAsync = function(path4, content, overwrite, attr, callback) {
+  Utils.prototype.writeFileToAsync = function(path3, content, overwrite, attr, callback) {
     if (typeof attr === "function") {
       callback = attr;
       attr = undefined;
     }
     const self2 = this;
-    self2.fs.exists(path4, function(exist) {
+    self2.fs.exists(path3, function(exist) {
       if (exist && !overwrite)
         return callback(false);
-      self2.fs.stat(path4, function(err, stat4) {
+      self2.fs.stat(path3, function(err, stat4) {
         if (exist && stat4.isDirectory()) {
           return callback(false);
         }
-        var folder = pth.dirname(path4);
+        var folder = pth.dirname(path3);
         self2.fs.exists(folder, function(exists) {
           if (!exists)
             self2.makeDir(folder);
-          self2.fs.open(path4, "w", 438, function(err2, fd) {
+          self2.fs.open(path3, "w", 438, function(err2, fd) {
             if (err2) {
-              self2.fs.chmod(path4, 438, function() {
-                self2.fs.open(path4, "w", 438, function(err3, fd2) {
+              self2.fs.chmod(path3, 438, function() {
+                self2.fs.open(path3, "w", 438, function(err3, fd2) {
                   self2.fs.write(fd2, content, 0, content.length, 0, function() {
                     self2.fs.close(fd2, function() {
-                      self2.fs.chmod(path4, attr || 438, function() {
+                      self2.fs.chmod(path3, attr || 438, function() {
                         callback(true);
                       });
                     });
@@ -197053,13 +197265,13 @@ var require_utils74 = __commonJS((exports, module) => {
             } else if (fd) {
               self2.fs.write(fd, content, 0, content.length, 0, function() {
                 self2.fs.close(fd, function() {
-                  self2.fs.chmod(path4, attr || 438, function() {
+                  self2.fs.chmod(path3, attr || 438, function() {
                     callback(true);
                   });
                 });
               });
             } else {
-              self2.fs.chmod(path4, attr || 438, function() {
+              self2.fs.chmod(path3, attr || 438, function() {
                 callback(true);
               });
             }
@@ -197068,7 +197280,7 @@ var require_utils74 = __commonJS((exports, module) => {
       });
     });
   };
-  Utils.prototype.findFiles = function(path4) {
+  Utils.prototype.findFiles = function(path3) {
     const self2 = this;
     function findSync(dir, pattern, recursive) {
       if (typeof pattern === "boolean") {
@@ -197077,17 +197289,17 @@ var require_utils74 = __commonJS((exports, module) => {
       }
       let files = [];
       self2.fs.readdirSync(dir).forEach(function(file) {
-        const path5 = pth.join(dir, file);
-        const stat4 = self2.fs.statSync(path5);
-        if (!pattern || pattern.test(path5)) {
-          files.push(pth.normalize(path5) + (stat4.isDirectory() ? self2.sep : ""));
+        const path4 = pth.join(dir, file);
+        const stat4 = self2.fs.statSync(path4);
+        if (!pattern || pattern.test(path4)) {
+          files.push(pth.normalize(path4) + (stat4.isDirectory() ? self2.sep : ""));
         }
         if (stat4.isDirectory() && recursive)
-          files = files.concat(findSync(path5, pattern, recursive));
+          files = files.concat(findSync(path4, pattern, recursive));
       });
       return files;
     }
-    return findSync(path4, undefined, true);
+    return findSync(path3, undefined, true);
   };
   Utils.prototype.findFilesAsync = function(dir, cb) {
     const self2 = this;
@@ -197147,16 +197359,16 @@ var require_utils74 = __commonJS((exports, module) => {
         return "UNSUPPORTED (" + method + ")";
     }
   };
-  Utils.canonical = function(path4) {
-    if (!path4)
+  Utils.canonical = function(path3) {
+    if (!path3)
       return "";
-    const safeSuffix = pth.posix.normalize("/" + path4.split("\\").join("/"));
+    const safeSuffix = pth.posix.normalize("/" + path3.split("\\").join("/"));
     return pth.join(".", safeSuffix);
   };
-  Utils.zipnamefix = function(path4) {
-    if (!path4)
+  Utils.zipnamefix = function(path3) {
+    if (!path3)
       return "";
-    const safeSuffix = pth.posix.normalize("/" + path4.split("\\").join("/"));
+    const safeSuffix = pth.posix.normalize("/" + path3.split("\\").join("/"));
     return pth.posix.join(".", safeSuffix);
   };
   Utils.findLast = function(arr, callback) {
@@ -197174,9 +197386,9 @@ var require_utils74 = __commonJS((exports, module) => {
     prefix = pth.resolve(pth.normalize(prefix));
     var parts = name.split("/");
     for (var i = 0, l = parts.length;i < l; i++) {
-      var path4 = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
-      if (path4.indexOf(prefix) === 0) {
-        return path4;
+      var path3 = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
+      if (path3.indexOf(prefix) === 0) {
+        return path3;
       }
     }
     return pth.normalize(pth.join(prefix, pth.basename(name)));
@@ -197214,8 +197426,8 @@ var require_utils74 = __commonJS((exports, module) => {
 // ../../node_modules/adm-zip/util/fattr.js
 var require_fattr = __commonJS((exports, module) => {
   var pth = __require("path");
-  module.exports = function(path4, { fs: fs2 }) {
-    var _path = path4 || "", _obj = newAttr(), _stat = null;
+  module.exports = function(path3, { fs: fs2 }) {
+    var _path = path3 || "", _obj = newAttr(), _stat = null;
     function newAttr() {
       return {
         directory: false,
@@ -198545,8 +198757,8 @@ var require_adm_zip = __commonJS((exports, module) => {
       return null;
     }
     function fixPath(zipPath) {
-      const { join: join4, normalize: normalize2, sep } = pth.posix;
-      return join4(".", normalize2(sep + zipPath.split("\\").join(sep) + sep));
+      const { join: join3, normalize: normalize2, sep } = pth.posix;
+      return join3(".", normalize2(sep + zipPath.split("\\").join(sep) + sep));
     }
     function filenameFilter(filterfn) {
       if (filterfn instanceof RegExp) {
@@ -199074,10 +199286,10 @@ var require_src122 = __commonJS((exports) => {
   var fs_1 = __require("fs");
   var debug_1 = __importDefault(require_src5());
   var log = debug_1.default("@kwsites/file-exists");
-  function check(path4, isFile2, isDirectory) {
-    log(`checking %s`, path4);
+  function check(path3, isFile2, isDirectory) {
+    log(`checking %s`, path3);
     try {
-      const stat4 = fs_1.statSync(path4);
+      const stat4 = fs_1.statSync(path3);
       if (stat4.isFile() && isFile2) {
         log(`[OK] path represents a file`);
         return true;
@@ -199097,8 +199309,8 @@ var require_src122 = __commonJS((exports) => {
       throw e;
     }
   }
-  function exists(path4, type = exports.READABLE) {
-    return check(path4, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+  function exists(path3, type = exports.READABLE) {
+    return check(path3, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
   }
   exports.exists = exists;
   exports.FILE = 1;
@@ -199156,6 +199368,441 @@ var require_dist12 = __commonJS((exports) => {
   exports.default = deferred;
 });
 
+// src/compile/compile_pool.ts
+var exports_compile_pool = {};
+__export(exports_compile_pool, {
+  getCompileWorkerCount: () => getCompileWorkerCount,
+  getCompilePool: () => getCompilePool,
+  __setCompilePoolForTests: () => __setCompilePoolForTests,
+  CompileWorkerPool: () => CompileWorkerPool
+});
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname3, join as join3 } from "path";
+import { Worker } from "node:worker_threads";
+function getCompileWorkerCount() {
+  const raw = process.env.MALLOY_COMPILE_WORKERS;
+  if (raw === undefined)
+    return 0;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    return 0;
+  return parsed;
+}
+function resolveWorkerScript() {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = dirname3(thisFile);
+  const distCandidate = join3(thisDir, "compile_worker.mjs");
+  if (thisFile.endsWith(".mjs") || thisFile.endsWith(".js")) {
+    return new URL(`file://${distCandidate}`);
+  }
+  const tsCandidate = join3(thisDir, "compile_worker.ts");
+  return new URL(`file://${tsCandidate}`);
+}
+
+class CompileWorkerPool {
+  workers = [];
+  maxWorkers;
+  nextWorkerId = 0;
+  jobs = new Map;
+  nextJobId = 0;
+  shuttingDown = false;
+  workerScript;
+  constructor(maxWorkers, workerScript) {
+    this.maxWorkers = maxWorkers;
+    this.workerScript = workerScript ?? resolveWorkerScript();
+  }
+  get enabled() {
+    return this.maxWorkers > 0;
+  }
+  get size() {
+    return this.workers.filter((w) => !w.exited).length;
+  }
+  async compile(request) {
+    if (!this.enabled) {
+      throw new Error("CompileWorkerPool.compile called while disabled (MALLOY_COMPILE_WORKERS=0)");
+    }
+    if (this.shuttingDown) {
+      throw new Error("CompileWorkerPool is shutting down");
+    }
+    const worker = await this.acquireWorker();
+    this.nextJobId += 1;
+    const jobId = `job-${this.nextJobId}`;
+    return new Promise((resolve3, reject) => {
+      const timeout = setTimeout(() => {
+        this.failJob(jobId, new Error(`Compile job timed out after ${COMPILE_JOB_TIMEOUT_MS}ms (model=${request.modelPath})`));
+      }, COMPILE_JOB_TIMEOUT_MS);
+      this.jobs.set(jobId, {
+        jobId,
+        connections: request.malloyConfig.connections,
+        urlReader: request.urlReader ?? defaultUrlReader,
+        resolve: (result) => {
+          clearTimeout(timeout);
+          resolve3(adaptResult(result));
+        },
+        reject: (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        },
+        timeout
+      });
+      worker.inFlight.add(jobId);
+      const message = {
+        type: "compile",
+        requestId: jobId,
+        packagePath: request.packagePath,
+        modelPath: request.modelPath,
+        defaultConnectionName: request.defaultConnectionName,
+        buildManifest: request.buildManifest
+      };
+      worker.worker.postMessage(message);
+    });
+  }
+  async shutdown() {
+    if (this.shuttingDown)
+      return;
+    this.shuttingDown = true;
+    const exits = this.workers.map((pw) => new Promise((resolve3) => {
+      if (pw.exited) {
+        resolve3();
+        return;
+      }
+      pw.worker.once("exit", () => resolve3());
+      const msg = { type: "shutdown" };
+      pw.worker.postMessage(msg);
+      setTimeout(() => {
+        if (!pw.exited) {
+          pw.worker.terminate().finally(() => resolve3());
+        }
+      }, 1e4);
+    }));
+    await Promise.all(exits);
+  }
+  async acquireWorker() {
+    this.workers.splice(0, this.workers.length, ...this.workers.filter((w) => !w.exited));
+    if (this.workers.length < this.maxWorkers) {
+      const pw = this.spawnWorker();
+      this.workers.push(pw);
+      await pw.ready;
+      return pw;
+    }
+    const alive = this.workers.filter((w) => !w.exited);
+    let best = alive[0];
+    for (const candidate of alive) {
+      if (candidate.inFlight.size < best.inFlight.size) {
+        best = candidate;
+      }
+    }
+    await best.ready;
+    return best;
+  }
+  spawnWorker() {
+    this.nextWorkerId += 1;
+    const id = this.nextWorkerId;
+    logger.info(`CompileWorkerPool: spawning worker #${id} (script=${this.workerScript.toString()})`);
+    const worker = new Worker(this.workerScript, {
+      name: `malloy-compile-worker-${id}`
+    });
+    let readyResolve;
+    const ready = new Promise((r) => readyResolve = r);
+    const pw = {
+      id,
+      worker,
+      ready,
+      inFlight: new Set,
+      exited: false
+    };
+    worker.on("message", (msg) => {
+      this.handleWorkerMessage(pw, msg, readyResolve);
+    });
+    worker.on("error", (err) => {
+      logger.error(`CompileWorkerPool: worker #${id} errored`, {
+        error: err
+      });
+    });
+    worker.on("exit", (code) => {
+      pw.exited = true;
+      logger.warn(`CompileWorkerPool: worker #${id} exited (code=${code}, inFlight=${pw.inFlight.size})`);
+      for (const jobId of pw.inFlight) {
+        this.failJob(jobId, new Error(`Compile worker #${id} exited unexpectedly (code=${code})`));
+      }
+      pw.inFlight.clear();
+    });
+    return pw;
+  }
+  handleWorkerMessage(pw, msg, markReady) {
+    switch (msg.type) {
+      case "ready":
+        markReady();
+        return;
+      case "compile-result":
+        this.completeJob(pw, msg);
+        return;
+      case "compile-error":
+        this.errorJob(pw, msg);
+        return;
+      case "connection-metadata":
+        this.handleConnectionMetadata(pw, msg);
+        return;
+      case "schema-for-tables":
+        this.handleSchemaForTables(pw, msg);
+        return;
+      case "schema-for-sql":
+        this.handleSchemaForSql(pw, msg);
+        return;
+      case "read-url":
+        this.handleReadUrl(pw, msg);
+        return;
+      default: {
+        const exhaustive = msg;
+        return;
+      }
+    }
+  }
+  async handleConnectionMetadata(pw, msg) {
+    const ctx = this.jobs.get(msg.jobId);
+    const reply = (response) => {
+      pw.worker.postMessage(response);
+    };
+    if (!ctx) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: { name: "Error", message: `Unknown jobId ${msg.jobId}` }
+      });
+      return;
+    }
+    try {
+      const conn = await ctx.connections.lookupConnection(msg.connectionName);
+      reply({
+        type: "connection-metadata-response",
+        requestId: msg.requestId,
+        ok: true,
+        metadata: {
+          name: msg.connectionName,
+          dialectName: conn.dialectName,
+          digest: typeof conn.getDigest === "function" ? conn.getDigest() : msg.connectionName
+        }
+      });
+    } catch (error) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: serializeError(error)
+      });
+    }
+  }
+  completeJob(pw, msg) {
+    const ctx = this.jobs.get(msg.requestId);
+    if (!ctx)
+      return;
+    this.jobs.delete(msg.requestId);
+    pw.inFlight.delete(msg.requestId);
+    ctx.resolve(msg);
+  }
+  errorJob(pw, msg) {
+    const ctx = this.jobs.get(msg.requestId);
+    if (!ctx)
+      return;
+    this.jobs.delete(msg.requestId);
+    pw.inFlight.delete(msg.requestId);
+    ctx.reject(deserializeError(msg.error));
+  }
+  failJob(jobId, error) {
+    const ctx = this.jobs.get(jobId);
+    if (!ctx)
+      return;
+    this.jobs.delete(jobId);
+    ctx.reject(error);
+  }
+  async handleSchemaForTables(pw, msg) {
+    const ctx = this.jobs.get(msg.jobId);
+    const reply = (response) => {
+      pw.worker.postMessage(response);
+    };
+    if (!ctx) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: { name: "Error", message: `Unknown jobId ${msg.jobId}` }
+      });
+      return;
+    }
+    try {
+      const conn = await ctx.connections.lookupConnection(msg.connectionName);
+      const result = await conn.fetchSchemaForTables(msg.tables, buildFetchOptions(msg.options));
+      reply({
+        type: "schema-for-tables-response",
+        requestId: msg.requestId,
+        ok: true,
+        schemas: result.schemas,
+        errors: result.errors
+      });
+    } catch (error) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: serializeError(error)
+      });
+    }
+  }
+  async handleSchemaForSql(pw, msg) {
+    const ctx = this.jobs.get(msg.jobId);
+    const reply = (response) => {
+      pw.worker.postMessage(response);
+    };
+    if (!ctx) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: { name: "Error", message: `Unknown jobId ${msg.jobId}` }
+      });
+      return;
+    }
+    try {
+      const conn = await ctx.connections.lookupConnection(msg.connectionName);
+      const result = await conn.fetchSchemaForSQLStruct(msg.sentence, buildFetchOptions(msg.options));
+      if (result.error !== undefined) {
+        reply({
+          type: "schema-for-sql-response",
+          requestId: msg.requestId,
+          ok: true,
+          error: result.error
+        });
+      } else {
+        reply({
+          type: "schema-for-sql-response",
+          requestId: msg.requestId,
+          ok: true,
+          structDef: result.structDef
+        });
+      }
+    } catch (error) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: serializeError(error)
+      });
+    }
+  }
+  async handleReadUrl(pw, msg) {
+    const ctx = this.jobs.get(msg.jobId);
+    const reply = (response) => {
+      pw.worker.postMessage(response);
+    };
+    if (!ctx) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: { name: "Error", message: `Unknown jobId ${msg.jobId}` }
+      });
+      return;
+    }
+    try {
+      const raw = await ctx.urlReader.readURL(new URL(msg.url));
+      const contents = typeof raw === "string" ? raw : raw.contents;
+      reply({
+        type: "read-url-response",
+        requestId: msg.requestId,
+        ok: true,
+        contents
+      });
+    } catch (error) {
+      reply({
+        type: "rpc-error",
+        requestId: msg.requestId,
+        ok: false,
+        error: serializeError(error)
+      });
+    }
+  }
+}
+function buildFetchOptions(options) {
+  const out = {};
+  if (options.refreshTimestamp !== undefined) {
+    out.refreshTimestamp = options.refreshTimestamp;
+  }
+  if (options.modelAnnotation !== undefined) {
+    out.modelAnnotation = options.modelAnnotation;
+  }
+  return out;
+}
+function adaptResult(result) {
+  return {
+    modelDef: result.modelDef,
+    sourceInfos: result.sourceInfos,
+    sources: result.sources,
+    queries: result.queries,
+    filterMap: new Map(result.filterMap.map(([k, v]) => [k, v])),
+    givens: result.givens,
+    compileDurationMs: result.compileDurationMs
+  };
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    };
+  }
+  return { name: "Error", message: String(error) };
+}
+function deserializeError(serialized) {
+  const err = new Error(serialized.message);
+  err.name = serialized.name;
+  if (serialized.stack)
+    err.stack = serialized.stack;
+  if (serialized.malloyProblems) {
+    err.problems = serialized.malloyProblems;
+  }
+  if (serialized.isCompilationError) {
+    const wrapped = new ModelCompilationError(err);
+    if (serialized.stack)
+      wrapped.stack = serialized.stack;
+    return wrapped;
+  }
+  return err;
+}
+function getCompilePool() {
+  if (singleton === null) {
+    const n = getCompileWorkerCount();
+    singleton = new CompileWorkerPool(n);
+    if (n > 0) {
+      logger.info(`Malloy compile worker pool enabled (size=${n}). Set MALLOY_COMPILE_WORKERS=0 to disable.`);
+    } else {
+      logger.info("Malloy compile worker pool DISABLED (MALLOY_COMPILE_WORKERS=0). Compile runs on the main event loop.");
+    }
+  }
+  return singleton;
+}
+async function __setCompilePoolForTests(pool) {
+  if (singleton && singleton !== pool) {
+    await singleton.shutdown();
+  }
+  singleton = pool;
+}
+var COMPILE_JOB_TIMEOUT_MS, defaultUrlReader, singleton = null;
+var init_compile_pool = __esm(() => {
+  init_errors();
+  init_logger();
+  COMPILE_JOB_TIMEOUT_MS = Number.parseInt(process.env.MALLOY_COMPILE_JOB_TIMEOUT_MS ?? "120000", 10);
+  defaultUrlReader = {
+    readURL: async (url2) => {
+      const { promises: fs3 } = await import("fs");
+      const { fileURLToPath: fileURLToPath3 } = await import("url");
+      const filePath = url2.protocol === "file:" ? fileURLToPath3(url2) : url2.toString();
+      return fs3.readFile(filePath, "utf8");
+    }
+  };
+});
+
 // ../../node_modules/concat-map/index.js
 var require_concat_map = __commonJS((exports, module) => {
   module.exports = function(xs, fn) {
@@ -199984,12 +200631,12 @@ var require_recursive_readdir = __commonJS((exports, module) => {
       ignores = [];
     }
     if (!callback) {
-      return new Promise(function(resolve3, reject) {
+      return new Promise(function(resolve4, reject) {
         readdir3(path7, ignores || [], function(err, data) {
           if (err) {
             reject(err);
           } else {
-            resolve3(data);
+            resolve4(data);
           }
         });
       });
@@ -200771,7 +201418,7 @@ var require_uri_all = __commonJS((exports, module) => {
       target.fragment = relative4.fragment;
       return target;
     }
-    function resolve3(baseURI, relativeURI, options) {
+    function resolve4(baseURI, relativeURI, options) {
       var schemelessOptions = assign({ scheme: "null" }, options);
       return serialize(resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
     }
@@ -201039,7 +201686,7 @@ var require_uri_all = __commonJS((exports, module) => {
     exports2.removeDotSegments = removeDotSegments;
     exports2.serialize = serialize;
     exports2.resolveComponents = resolveComponents;
-    exports2.resolve = resolve3;
+    exports2.resolve = resolve4;
     exports2.normalize = normalize2;
     exports2.equal = equal;
     exports2.escapeComponent = escapeComponent;
@@ -201405,20 +202052,20 @@ var require_resolve2 = __commonJS((exports, module) => {
   var util5 = require_util13();
   var SchemaObject = require_schema_obj();
   var traverse = require_json_schema_traverse();
-  module.exports = resolve3;
-  resolve3.normalizeId = normalizeId;
-  resolve3.fullPath = getFullPath;
-  resolve3.url = resolveUrl;
-  resolve3.ids = resolveIds;
-  resolve3.inlineRef = inlineRef;
-  resolve3.schema = resolveSchema;
-  function resolve3(compile, root, ref) {
+  module.exports = resolve4;
+  resolve4.normalizeId = normalizeId;
+  resolve4.fullPath = getFullPath;
+  resolve4.url = resolveUrl;
+  resolve4.ids = resolveIds;
+  resolve4.inlineRef = inlineRef;
+  resolve4.schema = resolveSchema;
+  function resolve4(compile, root, ref) {
     var refVal = this._refs[ref];
     if (typeof refVal == "string") {
       if (this._refs[refVal])
         refVal = this._refs[refVal];
       else
-        return resolve3.call(this, compile, root, refVal);
+        return resolve4.call(this, compile, root, refVal);
     }
     refVal = refVal || this._schemas[ref];
     if (refVal instanceof SchemaObject) {
@@ -201641,7 +202288,7 @@ var require_resolve2 = __commonJS((exports, module) => {
 
 // ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/error_classes.js
 var require_error_classes = __commonJS((exports, module) => {
-  var resolve3 = require_resolve2();
+  var resolve4 = require_resolve2();
   module.exports = {
     Validation: errorSubclass(ValidationError),
     MissingRef: errorSubclass(MissingRefError)
@@ -201656,8 +202303,8 @@ var require_error_classes = __commonJS((exports, module) => {
   };
   function MissingRefError(baseId, ref, message) {
     this.message = message || MissingRefError.message(baseId, ref);
-    this.missingRef = resolve3.url(baseId, ref);
-    this.missingSchema = resolve3.normalizeId(resolve3.fullPath(this.missingRef));
+    this.missingRef = resolve4.url(baseId, ref);
+    this.missingSchema = resolve4.normalizeId(resolve4.fullPath(this.missingRef));
   }
   function errorSubclass(Subclass) {
     Subclass.prototype = Object.create(Error.prototype);
@@ -202199,7 +202846,7 @@ var require_validate4 = __commonJS((exports, module) => {
 
 // ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/compile/index.js
 var require_compile2 = __commonJS((exports, module) => {
-  var resolve3 = require_resolve2();
+  var resolve4 = require_resolve2();
   var util5 = require_util13();
   var errorClasses = require_error_classes();
   var stableStringify = require_fast_json_stable_stringify();
@@ -202259,7 +202906,7 @@ var require_compile2 = __commonJS((exports, module) => {
         RULES,
         validate: validateGenerator,
         util: util5,
-        resolve: resolve3,
+        resolve: resolve4,
         resolveRef,
         usePattern,
         useDefault,
@@ -202298,7 +202945,7 @@ var require_compile2 = __commonJS((exports, module) => {
       return validate;
     }
     function resolveRef(baseId2, ref, isRoot) {
-      ref = resolve3.url(baseId2, ref);
+      ref = resolve4.url(baseId2, ref);
       var refIndex = refs[ref];
       var _refVal, refCode;
       if (refIndex !== undefined) {
@@ -202315,11 +202962,11 @@ var require_compile2 = __commonJS((exports, module) => {
         }
       }
       refCode = addLocalRef(ref);
-      var v2 = resolve3.call(self2, localCompile, root, ref);
+      var v2 = resolve4.call(self2, localCompile, root, ref);
       if (v2 === undefined) {
         var localSchema = localRefs && localRefs[ref];
         if (localSchema) {
-          v2 = resolve3.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self2, localSchema, root, localRefs, baseId2);
+          v2 = resolve4.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self2, localSchema, root, localRefs, baseId2);
         }
       }
       if (v2 === undefined) {
@@ -205836,7 +206483,7 @@ var require_data2 = __commonJS((exports, module) => {
 // ../../node_modules/@modelcontextprotocol/sdk/node_modules/ajv/lib/ajv.js
 var require_ajv = __commonJS((exports, module) => {
   var compileSchema = require_compile2();
-  var resolve3 = require_resolve2();
+  var resolve4 = require_resolve2();
   var Cache = require_cache();
   var SchemaObject = require_schema_obj();
   var stableStringify = require_fast_json_stable_stringify();
@@ -205928,7 +206575,7 @@ var require_ajv = __commonJS((exports, module) => {
     var id = this._getId(schema);
     if (id !== undefined && typeof id != "string")
       throw new Error("schema id must be string");
-    key = resolve3.normalizeId(key || id);
+    key = resolve4.normalizeId(key || id);
     checkUnique(this, key);
     this._schemas[key] = this._addSchema(schema, _skipValidation, _meta, true);
     return this;
@@ -205974,7 +206621,7 @@ var require_ajv = __commonJS((exports, module) => {
     }
   }
   function _getSchemaFragment(self2, ref) {
-    var res = resolve3.schema.call(self2, { schema: {} }, ref);
+    var res = resolve4.schema.call(self2, { schema: {} }, ref);
     if (res) {
       var { schema, root, baseId } = res;
       var v = compileSchema.call(self2, schema, root, undefined, baseId);
@@ -205990,7 +206637,7 @@ var require_ajv = __commonJS((exports, module) => {
     }
   }
   function _getSchemaObj(self2, keyRef) {
-    keyRef = resolve3.normalizeId(keyRef);
+    keyRef = resolve4.normalizeId(keyRef);
     return self2._schemas[keyRef] || self2._refs[keyRef] || self2._fragments[keyRef];
   }
   function removeSchema(schemaKeyRef) {
@@ -206018,7 +206665,7 @@ var require_ajv = __commonJS((exports, module) => {
         this._cache.del(cacheKey);
         var id = this._getId(schemaKeyRef);
         if (id) {
-          id = resolve3.normalizeId(id);
+          id = resolve4.normalizeId(id);
           delete this._schemas[id];
           delete this._refs[id];
         }
@@ -206043,14 +206690,14 @@ var require_ajv = __commonJS((exports, module) => {
     if (cached)
       return cached;
     shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false;
-    var id = resolve3.normalizeId(this._getId(schema));
+    var id = resolve4.normalizeId(this._getId(schema));
     if (id && shouldAddSchema)
       checkUnique(this, id);
     var willValidate = this._opts.validateSchema !== false && !skipValidation;
     var recursiveMeta;
-    if (willValidate && !(recursiveMeta = id && id == resolve3.normalizeId(schema.$schema)))
+    if (willValidate && !(recursiveMeta = id && id == resolve4.normalizeId(schema.$schema)))
       this.validateSchema(schema, true);
-    var localRefs = resolve3.ids.call(this, schema);
+    var localRefs = resolve4.ids.call(this, schema);
     var schemaObj = new SchemaObject({
       id,
       schema,
@@ -209093,7 +209740,7 @@ var require_util14 = __commonJS((exports) => {
       }
       path12 = url2.path;
     }
-    var isAbsolute3 = exports.isAbsolute(path12);
+    var isAbsolute4 = exports.isAbsolute(path12);
     var parts = path12.split(/\/+/);
     for (var part, up = 0, i = parts.length - 1;i >= 0; i--) {
       part = parts[i];
@@ -209113,7 +209760,7 @@ var require_util14 = __commonJS((exports) => {
     }
     path12 = parts.join("/");
     if (path12 === "") {
-      path12 = isAbsolute3 ? "/" : ".";
+      path12 = isAbsolute4 ? "/" : ".";
     }
     if (url2) {
       url2.path = path12;
@@ -211725,6 +212372,7 @@ var require_lib8 = __commonJS((exports, module) => {
 });
 
 // src/instrumentation.ts
+init_logger();
 var import_api = __toESM(require_src(), 1);
 var import_auto_instrumentations_node = __toESM(require_src59(), 1);
 var import_exporter_logs_otlp_proto = __toESM(require_src66(), 1);
@@ -211736,93 +212384,6 @@ var import_sdk_logs = __toESM(require_src75(), 1);
 var import_sdk_node = __toESM(require_src106(), 1);
 var import_sdk_trace_base = __toESM(require_src82(), 1);
 var import_semantic_conventions = __toESM(require_src2(), 1);
-
-// src/logger.ts
-var import_winston = __toESM(require_winston(), 1);
-var isTelemetryEnabled = Boolean(process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
-var VALID_LOG_LEVELS = ["error", "warn", "info", "verbose", "debug", "silly"];
-var getLogLevel = () => {
-  if (process.env.LOG_LEVEL) {
-    const logLevel = process.env.LOG_LEVEL.toLowerCase();
-    if (VALID_LOG_LEVELS.includes(logLevel)) {
-      return logLevel;
-    } else {
-      console.error(`Invalid log level: ${process.env.LOG_LEVEL}. Valid log levels are: ${VALID_LOG_LEVELS.join(", ")}. Defaulting to "debug".`);
-    }
-  }
-  return "debug";
-};
-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.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) {
-  if (!traceparent) {
-    return;
-  }
-  const parts = traceparent.split("-");
-  const traceId = parts.length >= 2 ? parts[1] : parts.length == 1 ? parts[0] : undefined;
-  if (traceId && traceId.length === 32 && /^[0-9a-fA-F]{32}$/.test(traceId)) {
-    return traceId;
-  }
-  return;
-}
-var DISABLE_RESPONSE_LOGGING = process.env.DISABLE_RESPONSE_LOGGING === "true" || process.env.DISABLE_RESPONSE_LOGGING === "1";
-function formatDuration(durationMs) {
-  if (durationMs >= 1000) {
-    const seconds = durationMs / 1000;
-    return `${seconds.toFixed(2)}s`;
-  }
-  return `${durationMs.toFixed(2)}ms`;
-}
-var loggerMiddleware = (req, res, next) => {
-  const startTime = performance.now();
-  const resJson = res.json;
-  res.json = (body) => {
-    res.locals.body = body;
-    return resJson.call(res, body);
-  };
-  res.on("finish", () => {
-    const endTime = performance.now();
-    const durationMs = endTime - startTime;
-    const traceparent = req.headers["traceparent"];
-    const traceId = extractTraceIdFromTraceparent(traceparent);
-    const logMetadata = {
-      statusCode: res.statusCode,
-      duration: formatDuration(durationMs),
-      payload: req.body,
-      params: req.params,
-      query: req.query
-    };
-    if (!DISABLE_RESPONSE_LOGGING) {
-      logMetadata.response = res.locals.body;
-    }
-    if (traceId) {
-      logMetadata.traceId = traceId;
-    }
-    if (req.url !== "/metrics" && req.url !== "/health" && req.url !== "/health/liveness" && req.url !== "/health/readiness") {
-      logger.info(`${req.method} ${req.url}`, logMetadata);
-    }
-  });
-  next();
-};
-var logAxiosError = (error) => {
-  if (error.response) {
-    logger.error("Axios server-side error", {
-      url: error.response.config.url,
-      status: error.response.status,
-      headers: error.response.headers,
-      data: error.response.data
-    });
-  } else if (error.request) {
-    logger.error("Axios client-side error", { error: error.request });
-  } else {
-    logger.error("Axios unknown error", { error });
-  }
-};
-
-// src/instrumentation.ts
 var prometheusExporter = null;
 var sdk = null;
 function getPrometheusMetricsHandler() {
@@ -216945,7 +217506,7 @@ var import_express = __toESM(require_express(), 1);
 var import_http_proxy_middleware = __toESM(require_dist4(), 1);
 import * as http2 from "http";
 import * as path12 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/controller/compile.controller.ts
 class CompileController {
@@ -216953,9 +217514,9 @@ class CompileController {
   constructor(environmentStore) {
     this.environmentStore = environmentStore;
   }
-  async compile(environmentName, packageName, modelName, source, includeSql = false) {
+  async compile(environmentName, packageName, modelName, source, includeSql = false, givens) {
     const environment = await this.environmentStore.getEnvironment(environmentName, false);
-    const { problems, sql } = await environment.compileSource(packageName, modelName, source, includeSql);
+    const { problems, sql } = await environment.compileSource(packageName, modelName, source, includeSql, givens);
     const hasErrors = problems.some((p) => p.severity === "error");
     return {
       status: hasErrors ? "error" : "success",
@@ -216965,140 +217526,9 @@ class CompileController {
   }
 }
 
-// src/errors.ts
-import { MalloyError } from "@malloydata/malloy";
-
-// src/constants.ts
-import os from "os";
-var API_PREFIX = "/api/v0";
-var README_NAME = "README.md";
-var PUBLISHER_CONFIG_NAME = "publisher.config.json";
-var PACKAGE_MANIFEST_NAME = "publisher.json";
-var MODEL_FILE_SUFFIX = ".malloy";
-var NOTEBOOK_FILE_SUFFIX = ".malloynb";
-var ROW_LIMIT = 1000;
-var TEMP_DIR_PATH = os.tmpdir();
-var PUBLISHER_DATA_DIR = "publisher_data";
-
-// src/errors.ts
-function internalErrorToHttpError(error) {
-  if (error instanceof BadRequestError) {
-    return httpError(400, error.message);
-  } else if (error instanceof FrozenConfigError) {
-    return httpError(403, error.message);
-  } else if (error instanceof EnvironmentNotFoundError) {
-    return httpError(404, error.message);
-  } else if (error instanceof PackageNotFoundError) {
-    return httpError(404, error.message);
-  } else if (error instanceof ModelNotFoundError) {
-    return httpError(404, error.message);
-  } else if (error instanceof MalloyError) {
-    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) {
-    return httpError(502, error.message);
-  } else if (error instanceof MaterializationNotFoundError) {
-    return httpError(404, error.message);
-  } else if (error instanceof MaterializationConflictError) {
-    return httpError(409, error.message);
-  } else if (error instanceof InvalidStateTransitionError) {
-    return httpError(409, error.message);
-  } else {
-    return httpError(500, error.message);
-  }
-}
-function httpError(code, message) {
-  return {
-    status: code,
-    json: {
-      code,
-      message
-    }
-  };
-}
-
-class NotImplementedError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class BadRequestError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class EnvironmentNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class PackageNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class ModelNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class ConnectionNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class ConnectionError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class ConnectionAuthError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class ModelCompilationError extends Error {
-  constructor(error) {
-    super(error.message);
-  }
-}
-
-class FrozenConfigError extends Error {
-  constructor(message = `Publisher config can't be updated when ${PUBLISHER_CONFIG_NAME} has { "frozenConfig": true }`) {
-    super(message);
-  }
-}
-
-class MaterializationNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class MaterializationConflictError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-class InvalidStateTransitionError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
+// src/controller/connection.controller.ts
+init_errors();
+init_logger();
 
 // src/service/connection.ts
 import"@malloydata/db-bigquery";
@@ -220383,10 +220813,12 @@ var {
 } = axios_default;
 
 // src/service/connection.ts
+init_logger();
 import fs from "fs/promises";
 import path2 from "path";
 
 // src/pg_helpers.ts
+init_errors();
 function pgConnectTimeoutSeconds() {
   const raw = process.env.PG_CONNECT_TIMEOUT_SECONDS;
   if (!raw)
@@ -221637,6 +222069,8 @@ async function testConnectionConfig(connectionConfig) {
 }
 
 // src/service/connection_service.ts
+init_errors();
+init_logger();
 async function runEnvironmentConnectionUpdate(environment, fn) {
   if (environment.runConnectionUpdateExclusive) {
     return environment.runConnectionUpdateExclusive(fn);
@@ -221748,11 +222182,13 @@ class ConnectionService {
 }
 
 // src/service/db_utils.ts
+init_logger();
 var import_bigquery = __toESM(require_src121(), 1);
 import { ClientSecretCredential } from "@azure/identity";
 import { ContainerClient } from "@azure/storage-blob";
 
 // src/service/gcs_s3_utils.ts
+init_logger();
 var import_client_s3 = __toESM(require_dist_cjs75(), 1);
 function gcsConnectionToCredentials(gcsConnection) {
   return {
@@ -223100,6 +223536,8 @@ class DatabaseController {
 }
 
 // src/controller/model.controller.ts
+init_errors();
+
 class ModelController {
   environmentStore;
   constructor(environmentStore) {
@@ -223146,7 +223584,7 @@ class ModelController {
     }
     return model.getNotebook();
   }
-  async executeNotebookCell(environmentName, packageName, notebookPath, cellIndex, filterParams, bypassFilters) {
+  async executeNotebookCell(environmentName, packageName, notebookPath, cellIndex, filterParams, bypassFilters, givens) {
     const environment = await this.environmentStore.getEnvironment(environmentName, false);
     const p = await environment.getPackage(packageName, false);
     const model = p.getModel(notebookPath);
@@ -223156,12 +223594,14 @@ class ModelController {
     if (model.getType() === "model") {
       throw new ModelNotFoundError(`${notebookPath} is a model`);
     }
-    return model.executeNotebookCell(cellIndex, filterParams, bypassFilters);
+    return model.executeNotebookCell(cellIndex, filterParams, bypassFilters, givens);
   }
 }
 
 // src/controller/package.controller.ts
-import * as path3 from "path";
+init_errors();
+init_logger();
+
 class PackageController {
   environmentStore;
   manifestService;
@@ -223175,11 +223615,20 @@ class PackageController {
   }
   async getPackage(environmentName, packageName, reload) {
     const environment = await this.environmentStore.getEnvironment(environmentName, false);
-    const _package = await environment.getPackage(packageName, reload);
-    const packageLocation = _package.getPackageMetadata().location;
-    if (reload && packageLocation) {
-      await this.downloadPackage(environmentName, packageName, packageLocation);
+    if (reload) {
+      let location;
+      try {
+        const cached = await environment.getPackage(packageName, false);
+        location = cached.getPackageMetadata().location;
+      } catch {}
+      if (location) {
+        const reinstalled = await environment.installPackage(packageName, (stagingPath) => this.downloadInto(environmentName, packageName, location, stagingPath));
+        return reinstalled.getPackageMetadata();
+      }
+      const _package2 = await environment.getPackage(packageName, true);
+      return _package2.getPackageMetadata();
     }
+    const _package = await environment.getPackage(packageName, false);
     return _package.getPackageMetadata();
   }
   async addPackage(environmentName, body, options) {
@@ -223189,14 +223638,18 @@ class PackageController {
     if (!body.name) {
       throw new BadRequestError("Package name is required");
     }
+    const packageName = body.name;
     const environment = await this.environmentStore.getEnvironment(environmentName, false);
+    let result;
     if (body.location) {
-      await this.downloadPackage(environmentName, body.name, body.location);
+      const bodyLocation = body.location;
+      result = await environment.installPackage(packageName, (stagingPath) => this.downloadInto(environmentName, packageName, bodyLocation, stagingPath));
+    } else {
+      result = await environment.addPackage(packageName);
     }
-    const result = await environment.addPackage(body.name);
-    await this.environmentStore.addPackageToDatabase(environmentName, body.name);
+    await this.environmentStore.addPackageToDatabase(environmentName, packageName);
     if (options?.autoLoadManifest === true) {
-      await this.tryLoadExistingManifest(environmentName, body.name);
+      await this.tryLoadExistingManifest(environmentName, packageName);
     }
     return result;
   }
@@ -223238,29 +223691,31 @@ class PackageController {
     }
     const environment = await this.environmentStore.getEnvironment(environmentName, false);
     if (body.location) {
-      await this.downloadPackage(environmentName, packageName, body.location);
+      const bodyLocation = body.location;
+      await environment.installPackage(packageName, (stagingPath) => this.downloadInto(environmentName, packageName, bodyLocation, stagingPath));
     }
     const result = await environment.updatePackage(packageName, body);
     await this.environmentStore.addPackageToDatabase(environmentName, packageName);
     return result;
   }
-  async downloadPackage(environmentName, packageName, packageLocation) {
-    const absoluteTargetPath = path3.join(this.environmentStore.serverRootPath, PUBLISHER_DATA_DIR, environmentName, packageName);
+  async downloadInto(environmentName, packageName, packageLocation, targetPath) {
     const isCompressedFile = packageLocation.endsWith(".zip");
     if (packageLocation.startsWith("https://") || packageLocation.startsWith("git@")) {
-      await this.environmentStore.downloadGitHubDirectory(packageLocation, absoluteTargetPath);
+      await this.environmentStore.downloadGitHubDirectory(packageLocation, targetPath);
     } else if (packageLocation.startsWith("gs://")) {
-      await this.environmentStore.downloadGcsDirectory(packageLocation, environmentName, absoluteTargetPath, isCompressedFile);
+      await this.environmentStore.downloadGcsDirectory(packageLocation, environmentName, targetPath, isCompressedFile);
     } else if (packageLocation.startsWith("s3://")) {
-      await this.environmentStore.downloadS3Directory(packageLocation, environmentName, absoluteTargetPath, isCompressedFile);
+      await this.environmentStore.downloadS3Directory(packageLocation, environmentName, targetPath, isCompressedFile);
     }
     if (packageLocation.startsWith("/")) {
-      await this.environmentStore.mountLocalDirectory(packageLocation, absoluteTargetPath, environmentName, packageName);
+      await this.environmentStore.mountLocalDirectory(packageLocation, targetPath, environmentName, packageName);
     }
   }
 }
 
 // src/controller/query.controller.ts
+init_constants();
+init_errors();
 var import_render_validator = __toESM(require_dist10(), 1);
 function bigIntReplacer(_key, value) {
   if (typeof value === "bigint") {
@@ -223274,14 +223729,14 @@ class QueryController {
   constructor(environmentStore) {
     this.environmentStore = environmentStore;
   }
-  async getQuery(environmentName, packageName, modelPath, sourceName, queryName, query, compactJson = false, filterParams, bypassFilters) {
+  async getQuery(environmentName, packageName, modelPath, sourceName, queryName, query, compactJson = false, filterParams, bypassFilters, givens) {
     const environment = await this.environmentStore.getEnvironment(environmentName, false);
     const p = await environment.getPackage(packageName, false);
     const model = p.getModel(modelPath);
     if (!model) {
       throw new ModelNotFoundError(`${modelPath} does not exist`);
     } else {
-      const { result, compactResult } = await model.getQueryResults(sourceName, queryName, query, filterParams, bypassFilters);
+      const { result, compactResult } = await model.getQueryResults(sourceName, queryName, query, filterParams, bypassFilters, givens);
       const renderLogs = import_render_validator.validateRenderTags(result);
       return {
         result: compactJson ? JSON.stringify(compactResult, bigIntReplacer) : JSON.stringify(result),
@@ -223369,7 +223824,7 @@ class ReaddirpStream extends Readable2 {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path4) => statMethod(path4, { bigint: true });
+      this._stat = (path3) => statMethod(path3, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -223394,8 +223849,8 @@ class ReaddirpStream extends Readable2 {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path4, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path4));
+          const { path: path3, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path3));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -223435,20 +223890,20 @@ class ReaddirpStream extends Readable2 {
       this.reading = false;
     }
   }
-  async _exploreDir(path4, depth) {
+  async _exploreDir(path3, depth) {
     let files;
     try {
-      files = await readdir(path4, this._rdOptions);
+      files = await readdir(path3, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path4 };
+    return { files, depth, path: path3 };
   }
-  async _formatEntry(dirent, path4) {
+  async _formatEntry(dirent, path3) {
     let entry;
     const basename = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path4, basename));
+      const fullPath = presolve(pjoin(path3, basename));
       entry = { path: prelative(this._root, fullPath), fullPath, basename };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -223847,16 +224302,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = new Map;
-function createFsWatchInstance(path4, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path3, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path4);
-    emitRaw(rawEvent, evPath, { watchedPath: path4 });
-    if (evPath && path4 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path4, evPath), KEY_LISTENERS, sysPath.join(path4, evPath));
+    listener(path3);
+    emitRaw(rawEvent, evPath, { watchedPath: path3 });
+    if (evPath && path3 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path3, evPath), KEY_LISTENERS, sysPath.join(path3, evPath));
     }
   };
   try {
-    return fs_watch(path4, {
+    return fs_watch(path3, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -223872,12 +224327,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path4, fullPath, options, handlers) => {
+var setFsWatchListener = (path3, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path4, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path3, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -223887,7 +224342,7 @@ var setFsWatchListener = (path4, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_ERR, errHandler);
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
-    watcher = createFsWatchInstance(path4, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
+    watcher = createFsWatchInstance(path3, options, fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS), errHandler, fsWatchBroadcast.bind(null, fullPath, KEY_RAW));
     if (!watcher)
       return;
     watcher.on(EV.ERROR, async (error) => {
@@ -223896,7 +224351,7 @@ var setFsWatchListener = (path4, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path4, "r");
+          const fd = await open(path3, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {}
@@ -223926,7 +224381,7 @@ var setFsWatchListener = (path4, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = new Map;
-var setFsWatchFileListener = (path4, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path3, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -223948,7 +224403,7 @@ var setFsWatchFileListener = (path4, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path4, curr));
+          foreach(cont.listeners, (listener2) => listener2(path3, curr));
         }
       })
     };
@@ -223971,13 +224426,13 @@ class NodeFsHandler {
     this.fsw = fsW;
     this._boundHandleError = (error) => fsW._handleError(error);
   }
-  _watchWithNodeFs(path4, listener) {
+  _watchWithNodeFs(path3, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path4);
-    const basename2 = sysPath.basename(path4);
+    const directory = sysPath.dirname(path3);
+    const basename2 = sysPath.basename(path3);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename2);
-    const absolutePath = sysPath.resolve(path4);
+    const absolutePath = sysPath.resolve(path3);
     const options = {
       persistent: opts.persistent
     };
@@ -223987,12 +224442,12 @@ class NodeFsHandler {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename2) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path4, absolutePath, options, {
+      closer = setFsWatchFileListener(path3, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path4, absolutePath, options, {
+      closer = setFsWatchListener(path3, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -224010,7 +224465,7 @@ class NodeFsHandler {
     let prevStats = stats;
     if (parent.has(basename2))
       return;
-    const listener = async (path4, newStats) => {
+    const listener = async (path3, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -224024,11 +224479,11 @@ class NodeFsHandler {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path4);
+            this.fsw._closeFile(path3);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path4, closer2);
+              this.fsw._addPathCloser(path3, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -224052,7 +224507,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path4, item) {
+  async _handleSymlink(entry, directory, path3, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -224062,7 +224517,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path4);
+        linkPath = await fsrealpath(path3);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -224072,12 +224527,12 @@ class NodeFsHandler {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path4, entry.stats);
+          this.fsw._emit(EV.CHANGE, path3, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path4, entry.stats);
+        this.fsw._emit(EV.ADD, path3, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -224106,9 +224561,9 @@ class NodeFsHandler {
         return;
       }
       const item = entry.path;
-      let path4 = sysPath.join(directory, item);
+      let path3 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path4, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path3, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -224117,8 +224572,8 @@ class NodeFsHandler {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path4 = sysPath.join(dir, sysPath.relative(dir, path4));
-        this._addToNodeFs(path4, initialAdd, wh, depth + 1);
+        path3 = sysPath.join(dir, sysPath.relative(dir, path3));
+        this._addToNodeFs(path3, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve2, reject) => {
@@ -224167,13 +224622,13 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _addToNodeFs(path4, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path3, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path4) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path3) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path4);
+    const wh = this.fsw._getWatchHelpers(path3);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -224189,8 +224644,8 @@ class NodeFsHandler {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path4);
-        const targetPath = follow ? await fsrealpath(path4) : path4;
+        const absPath = sysPath.resolve(path3);
+        const targetPath = follow ? await fsrealpath(path3) : path3;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -224200,29 +224655,29 @@ class NodeFsHandler {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path4) : path4;
+        const targetPath = follow ? await fsrealpath(path3) : path3;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path4, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path3, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== undefined) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path4), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path3), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path4, closer);
+        this.fsw._addPathCloser(path3, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path4;
+        return path3;
       }
     }
   }
@@ -224266,26 +224721,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path4) {
-  if (typeof path4 !== "string")
+function normalizePath(path3) {
+  if (typeof path3 !== "string")
     throw new Error("string expected");
-  path4 = sysPath2.normalize(path4);
-  path4 = path4.replace(/\\/g, "/");
+  path3 = sysPath2.normalize(path3);
+  path3 = path3.replace(/\\/g, "/");
   let prepend = false;
-  if (path4.startsWith("//"))
+  if (path3.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path4.match(DOUBLE_SLASH_RE2))
-    path4 = path4.replace(DOUBLE_SLASH_RE2, "/");
+  while (path3.match(DOUBLE_SLASH_RE2))
+    path3 = path3.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path4 = "/" + path4;
-  return path4;
+    path3 = "/" + path3;
+  return path3;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path4 = normalizePath(testString);
+  const path3 = normalizePath(testString);
   for (let index = 0;index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path4, stats)) {
+    if (pattern(path3, stats)) {
       return true;
     }
   }
@@ -224325,19 +224780,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path4) => toUnix(sysPath2.normalize(toUnix(path4)));
-var normalizeIgnored = (cwd = "") => (path4) => {
-  if (typeof path4 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path4) ? path4 : sysPath2.join(cwd, path4));
+var normalizePathToUnix = (path3) => toUnix(sysPath2.normalize(toUnix(path3)));
+var normalizeIgnored = (cwd = "") => (path3) => {
+  if (typeof path3 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path3) ? path3 : sysPath2.join(cwd, path3));
   } else {
-    return path4;
+    return path3;
   }
 };
-var getAbsolutePath = (path4, cwd) => {
-  if (sysPath2.isAbsolute(path4)) {
-    return path4;
+var getAbsolutePath = (path3, cwd) => {
+  if (sysPath2.isAbsolute(path3)) {
+    return path3;
   }
-  return sysPath2.join(cwd, path4);
+  return sysPath2.join(cwd, path3);
 };
 var EMPTY_SET = Object.freeze(new Set);
 
@@ -224394,10 +224849,10 @@ var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 
 class WatchHelper {
-  constructor(path4, follow, fsw) {
+  constructor(path3, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path4;
-    this.path = path4 = path4.replace(REPLACER_RE, "");
+    const watchPath = path3;
+    this.path = path3 = path3.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -224510,20 +224965,20 @@ class FSWatcher extends EventEmitter2 {
     this._closePromise = undefined;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path4) => {
-        const absPath = getAbsolutePath(path4, cwd);
+      paths = paths.map((path3) => {
+        const absPath = getAbsolutePath(path3, cwd);
         return absPath;
       });
     }
-    paths.forEach((path4) => {
-      this._removeIgnoredPath(path4);
+    paths.forEach((path3) => {
+      this._removeIgnoredPath(path3);
     });
     this._userIgnored = undefined;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path4) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path4, !_internal, undefined, 0, _origAdd);
+    Promise.all(paths.map(async (path3) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path3, !_internal, undefined, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -224542,17 +224997,17 @@ class FSWatcher extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path4) => {
-      if (!sysPath2.isAbsolute(path4) && !this._closers.has(path4)) {
+    paths.forEach((path3) => {
+      if (!sysPath2.isAbsolute(path3) && !this._closers.has(path3)) {
         if (cwd)
-          path4 = sysPath2.join(cwd, path4);
-        path4 = sysPath2.resolve(path4);
+          path3 = sysPath2.join(cwd, path3);
+        path3 = sysPath2.resolve(path3);
       }
-      this._closePath(path4);
-      this._addIgnoredPath(path4);
-      if (this._watched.has(path4)) {
+      this._closePath(path3);
+      this._addIgnoredPath(path3);
+      if (this._watched.has(path3)) {
         this._addIgnoredPath({
-          path: path4,
+          path: path3,
           recursive: true
         });
       }
@@ -224601,38 +225056,38 @@ class FSWatcher extends EventEmitter2 {
     if (event !== EVENTS.ERROR)
       this.emit(EVENTS.ALL, event, ...args);
   }
-  async _emit(event, path4, stats) {
+  async _emit(event, path3, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path4 = sysPath2.normalize(path4);
+      path3 = sysPath2.normalize(path3);
     if (opts.cwd)
-      path4 = sysPath2.relative(opts.cwd, path4);
-    const args = [path4];
+      path3 = sysPath2.relative(opts.cwd, path3);
+    const args = [path3];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path4))) {
+    if (awf && (pw = this._pendingWrites.get(path3))) {
       pw.lastChange = new Date;
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path4, [event, ...args]);
+        this._pendingUnlinks.set(path3, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path5) => {
+          this._pendingUnlinks.forEach((entry, path4) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path5);
+            this._pendingUnlinks.delete(path4);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path4)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path3)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path4);
+        this._pendingUnlinks.delete(path3);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -224650,16 +225105,16 @@ class FSWatcher extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path4, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path3, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path4, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path3, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === undefined && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path4) : path4;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path3) : path3;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -224678,23 +225133,23 @@ class FSWatcher extends EventEmitter2 {
     }
     return error || this.closed;
   }
-  _throttle(actionType, path4, timeout) {
+  _throttle(actionType, path3, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, new Map);
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path4);
+    const actionPath = action.get(path3);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path4);
+      const item = action.get(path3);
       const count = item ? item.count : 0;
-      action.delete(path4);
+      action.delete(path3);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -224702,50 +225157,50 @@ class FSWatcher extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path4, thr);
+    action.set(path3, thr);
     return thr;
   }
   _incrReadyCount() {
     return this._readyCount++;
   }
-  _awaitWriteFinish(path4, threshold, event, awfEmit) {
+  _awaitWriteFinish(path3, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path4;
-    if (this.options.cwd && !sysPath2.isAbsolute(path4)) {
-      fullPath = sysPath2.join(this.options.cwd, path4);
+    let fullPath = path3;
+    if (this.options.cwd && !sysPath2.isAbsolute(path3)) {
+      fullPath = sysPath2.join(this.options.cwd, path3);
     }
     const now = new Date;
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path4)) {
+        if (err || !writes.has(path3)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(new Date);
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path4).lastChange = now2;
+          writes.get(path3).lastChange = now2;
         }
-        const pw = writes.get(path4);
+        const pw = writes.get(path3);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path4);
+          writes.delete(path3);
           awfEmit(undefined, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path4)) {
-      writes.set(path4, {
+    if (!writes.has(path3)) {
+      writes.set(path3, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path4);
+          writes.delete(path3);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -224753,8 +225208,8 @@ class FSWatcher extends EventEmitter2 {
       timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
     }
   }
-  _isIgnored(path4, stats) {
-    if (this.options.atomic && DOT_RE.test(path4))
+  _isIgnored(path3, stats) {
+    if (this.options.atomic && DOT_RE.test(path3))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -224764,13 +225219,13 @@ class FSWatcher extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, undefined);
     }
-    return this._userIgnored(path4, stats);
+    return this._userIgnored(path3, stats);
   }
-  _isntIgnored(path4, stat4) {
-    return !this._isIgnored(path4, stat4);
+  _isntIgnored(path3, stat4) {
+    return !this._isIgnored(path3, stat4);
   }
-  _getWatchHelpers(path4) {
-    return new WatchHelper(path4, this.options.followSymlinks, this);
+  _getWatchHelpers(path3) {
+    return new WatchHelper(path3, this.options.followSymlinks, this);
   }
   _getWatchedDir(directory) {
     const dir = sysPath2.resolve(directory);
@@ -224784,57 +225239,57 @@ class FSWatcher extends EventEmitter2 {
     return Boolean(Number(stats.mode) & 256);
   }
   _remove(directory, item, isDirectory) {
-    const path4 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path4);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path4) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path4, 100))
+    const path3 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path3);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path3) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path3, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path4);
+    const wp = this._getWatchedDir(path3);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path4, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path3, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path4;
+    let relPath = path3;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path4);
+      relPath = sysPath2.relative(this.options.cwd, path3);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path4);
+    this._watched.delete(path3);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path4))
-      this._emit(eventName, path4);
-    this._closePath(path4);
+    if (wasTracked && !this._isIgnored(path3))
+      this._emit(eventName, path3);
+    this._closePath(path3);
   }
-  _closePath(path4) {
-    this._closeFile(path4);
-    const dir = sysPath2.dirname(path4);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path4));
+  _closePath(path3) {
+    this._closeFile(path3);
+    const dir = sysPath2.dirname(path3);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path3));
   }
-  _closeFile(path4) {
-    const closers = this._closers.get(path4);
+  _closeFile(path3) {
+    const closers = this._closers.get(path3);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path4);
+    this._closers.delete(path3);
   }
-  _addPathCloser(path4, closer) {
+  _addPathCloser(path3, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path4);
+    let list = this._closers.get(path3);
     if (!list) {
       list = [];
-      this._closers.set(path4, list);
+      this._closers.set(path3, list);
     }
     list.push(closer);
   }
@@ -224864,6 +225319,7 @@ function watch(paths, options = {}) {
 var esm_default = { watch, FSWatcher };
 
 // src/controller/watch-mode.controller.ts
+init_logger();
 import path11 from "path";
 
 // src/service/environment_store.ts
@@ -225080,7 +225536,7 @@ class Mutex {
 }
 
 // src/service/environment_store.ts
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 import * as fs7 from "fs";
 import * as path10 from "path";
 
@@ -225096,7 +225552,7 @@ var __defProp2 = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames2 = Object.getOwnPropertyNames;
 var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
+var __esm2 = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
 };
 var __commonJS2 = (cb, mod2) => function __require2() {
@@ -225120,20 +225576,20 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path4) {
-  return path4 instanceof String && cache.has(path4);
+function isPathSpec(path3) {
+  return path3 instanceof String && cache.has(path3);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
 }
 var cache;
-var init_pathspec = __esm({
+var init_pathspec = __esm2({
   "src/lib/args/pathspec.ts"() {
     cache = /* @__PURE__ */ new WeakMap;
   }
 });
 var GitError;
-var init_git_error = __esm({
+var init_git_error = __esm2({
   "src/lib/errors/git-error.ts"() {
     GitError = class extends Error {
       constructor(task, message) {
@@ -225145,7 +225601,7 @@ var init_git_error = __esm({
   }
 });
 var GitResponseError;
-var init_git_response_error = __esm({
+var init_git_response_error = __esm2({
   "src/lib/errors/git-response-error.ts"() {
     init_git_error();
     GitResponseError = class extends GitError {
@@ -225157,7 +225613,7 @@ var init_git_response_error = __esm({
   }
 });
 var TaskConfigurationError;
-var init_task_configuration_error = __esm({
+var init_task_configuration_error = __esm2({
   "src/lib/errors/task-configuration-error.ts"() {
     init_git_error();
     TaskConfigurationError = class extends GitError {
@@ -225207,8 +225663,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = `
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path4) {
-  return import_file_exists.exists(path4, import_file_exists.FOLDER);
+function folderExists(path3) {
+  return import_file_exists.exists(path3, import_file_exists.FOLDER);
 }
 function append2(target, item) {
   if (Array.isArray(target)) {
@@ -225280,7 +225736,7 @@ function orVoid(input) {
 var NULL;
 var NOOP;
 var objectToString;
-var init_util = __esm({
+var init_util = __esm2({
   "src/lib/utils/util.ts"() {
     NULL = "\x00";
     NOOP = () => {};
@@ -225308,7 +225764,7 @@ var filterString;
 var filterStringArray;
 var filterStringOrStringArray;
 var filterHasLength;
-var init_argument_filters = __esm({
+var init_argument_filters = __esm2({
   "src/lib/utils/argument-filters.ts"() {
     init_util();
     init_pathspec();
@@ -225333,7 +225789,7 @@ var init_argument_filters = __esm({
   }
 });
 var ExitCodes;
-var init_exit_codes = __esm({
+var init_exit_codes = __esm2({
   "src/lib/utils/exit-codes.ts"() {
     ExitCodes = /* @__PURE__ */ ((ExitCodes2) => {
       ExitCodes2[ExitCodes2["SUCCESS"] = 0] = "SUCCESS";
@@ -225345,7 +225801,7 @@ var init_exit_codes = __esm({
   }
 });
 var GitOutputStreams;
-var init_git_output_streams = __esm({
+var init_git_output_streams = __esm2({
   "src/lib/utils/git-output-streams.ts"() {
     GitOutputStreams = class _GitOutputStreams {
       constructor(stdOut, stdErr) {
@@ -225360,7 +225816,7 @@ var init_git_output_streams = __esm({
 });
 var LineParser;
 var RemoteLineParser;
-var init_line_parser = __esm({
+var init_line_parser = __esm2({
   "src/lib/utils/line-parser.ts"() {
     LineParser = class {
       constructor(regExp, useMatches) {
@@ -225417,7 +225873,7 @@ function createInstanceConfig(...options) {
   return config;
 }
 var defaultOptions2;
-var init_simple_git_options = __esm({
+var init_simple_git_options = __esm2({
   "src/lib/utils/simple-git-options.ts"() {
     defaultOptions2 = {
       binary: "git",
@@ -225474,7 +225930,7 @@ function trailingFunctionArgument(args, includeNoop = true) {
   const callback = asFunction(last(args));
   return includeNoop || isUserFunction(callback) ? callback : undefined;
 }
-var init_task_options = __esm({
+var init_task_options = __esm2({
   "src/lib/utils/task-options.ts"() {
     init_argument_filters();
     init_util();
@@ -225498,7 +225954,7 @@ function parseStringResponse(result, parsers12, texts, trim2 = true) {
   });
   return result;
 }
-var init_task_parser = __esm({
+var init_task_parser = __esm2({
   "src/lib/utils/task-parser.ts"() {
     init_util();
   }
@@ -225549,7 +226005,7 @@ __export2(utils_exports, {
   trailingFunctionArgument: () => trailingFunctionArgument,
   trailingOptionsArgument: () => trailingOptionsArgument
 });
-var init_utils = __esm({
+var init_utils = __esm2({
   "src/lib/utils/index.ts"() {
     init_argument_filters();
     init_exit_codes();
@@ -225589,8 +226045,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path4) {
-      return /^\.(git)?$/.test(path4.trim());
+    parser(path3) {
+      return /^\.(git)?$/.test(path3.trim());
     }
   };
 }
@@ -225609,7 +226065,7 @@ function isNotRepoMessage(error) {
 var CheckRepoActions;
 var onError;
 var parser;
-var init_check_is_repo = __esm({
+var init_check_is_repo = __esm2({
   "src/lib/tasks/check-is-repo.ts"() {
     init_utils();
     CheckRepoActions = /* @__PURE__ */ ((CheckRepoActions2) => {
@@ -225643,7 +226099,7 @@ var CleanResponse;
 var removalRegexp;
 var dryRunRemovalRegexp;
 var isFolderRegexp;
-var init_CleanSummary = __esm({
+var init_CleanSummary = __esm2({
   "src/lib/responses/CleanSummary.ts"() {
     init_utils();
     CleanResponse = class {
@@ -225710,7 +226166,7 @@ function isEmptyTask(task) {
   return task.format === "empty" || !task.commands.length;
 }
 var EMPTY_COMMANDS;
-var init_task = __esm({
+var init_task = __esm2({
   "src/lib/tasks/task.ts"() {
     init_task_configuration_error();
     EMPTY_COMMANDS = [];
@@ -225788,7 +226244,7 @@ var CONFIG_ERROR_MODE_REQUIRED;
 var CONFIG_ERROR_UNKNOWN_OPTION;
 var CleanOptions;
 var CleanOptionValues;
-var init_clean = __esm({
+var init_clean = __esm2({
   "src/lib/tasks/clean.ts"() {
     init_CleanSummary();
     init_utils();
@@ -225861,7 +226317,7 @@ function* configParser(text, requestedKey = null) {
   }
 }
 var ConfigList;
-var init_ConfigList = __esm({
+var init_ConfigList = __esm2({
   "src/lib/responses/ConfigList.ts"() {
     init_utils();
     ConfigList = class {
@@ -225959,7 +226415,7 @@ function config_default() {
   };
 }
 var GitConfigScope;
-var init_config = __esm({
+var init_config = __esm2({
   "src/lib/tasks/config.ts"() {
     init_ConfigList();
     init_utils();
@@ -225977,7 +226433,7 @@ function isDiffNameStatus(input) {
 }
 var DiffNameStatus;
 var diffNameStatus;
-var init_diff_name_status = __esm({
+var init_diff_name_status = __esm2({
   "src/lib/tasks/diff-name-status.ts"() {
     DiffNameStatus = /* @__PURE__ */ ((DiffNameStatus2) => {
       DiffNameStatus2["ADDED"] = "A";
@@ -226001,11 +226457,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set;
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path4, line, preview] = input.split(NULL);
-    paths.add(path4);
-    (results[path4] = results[path4] || []).push({
+    const [path3, line, preview] = input.split(NULL);
+    paths.add(path3);
+    (results[path3] = results[path3] || []).push({
       line: asNumber(line),
-      path: path4,
+      path: path3,
       preview
     });
   });
@@ -226042,7 +226498,7 @@ var disallowedOptions;
 var Query;
 var _a;
 var GrepQuery;
-var init_grep = __esm({
+var init_grep = __esm2({
   "src/lib/tasks/grep.ts"() {
     init_utils();
     init_task();
@@ -226098,7 +226554,7 @@ function isValidResetMode(mode) {
 }
 var ResetMode;
 var ResetModes;
-var init_reset = __esm({
+var init_reset = __esm2({
   "src/lib/tasks/reset.ts"() {
     init_task();
     ResetMode = /* @__PURE__ */ ((ResetMode2) => {
@@ -226160,7 +226616,7 @@ function createLogger(label, verbose, initialStep, infoDebugger = createLog()) {
     });
   }
 }
-var init_git_logger = __esm({
+var init_git_logger = __esm2({
   "src/lib/git-logger.ts"() {
     init_utils();
     import_debug.default.formatters.L = (value) => String(filterHasLength(value) ? value.length : "-");
@@ -226173,7 +226629,7 @@ var init_git_logger = __esm({
   }
 });
 var TasksPendingQueue;
-var init_tasks_pending_queue = __esm({
+var init_tasks_pending_queue = __esm2({
   "src/lib/runners/tasks-pending-queue.ts"() {
     init_git_error();
     init_git_logger();
@@ -226257,7 +226713,7 @@ function onDataReceived(target, name, logger2, output) {
   };
 }
 var GitExecutorChain;
-var init_git_executor_chain = __esm({
+var init_git_executor_chain = __esm2({
   "src/lib/runners/git-executor-chain.ts"() {
     init_git_error();
     init_task();
@@ -226422,7 +226878,7 @@ __export2(git_executor_exports, {
   GitExecutor: () => GitExecutor
 });
 var GitExecutor;
-var init_git_executor = __esm({
+var init_git_executor = __esm2({
   "src/lib/runners/git-executor.ts"() {
     init_git_executor_chain();
     GitExecutor = class {
@@ -226473,7 +226929,7 @@ function addDeprecationNoticeToError(err) {
     return all3;
   }
 }
-var init_task_callback = __esm({
+var init_task_callback = __esm2({
   "src/lib/task-callback.ts"() {
     init_git_response_error();
     init_utils();
@@ -226487,7 +226943,7 @@ function changeWorkingDirectoryTask(directory, root) {
     return (root || instance).cwd = directory;
   });
 }
-var init_change_working_directory = __esm({
+var init_change_working_directory = __esm2({
   "src/lib/tasks/change-working-directory.ts"() {
     init_utils();
     init_task();
@@ -226513,7 +226969,7 @@ function checkout_default() {
     }
   };
 }
-var init_checkout = __esm({
+var init_checkout = __esm2({
   "src/lib/tasks/checkout.ts"() {
     init_utils();
     init_task();
@@ -226545,7 +227001,7 @@ function count_objects_default() {
   };
 }
 var parser2;
-var init_count_objects = __esm({
+var init_count_objects = __esm2({
   "src/lib/tasks/count-objects.ts"() {
     init_utils();
     parser2 = new LineParser(/([a-z-]+): (\d+)$/, (result, [key, value]) => {
@@ -226571,7 +227027,7 @@ function parseCommitResult(stdOut) {
   return parseStringResponse(result, parsers, stdOut);
 }
 var parsers;
-var init_parse_commit = __esm({
+var init_parse_commit = __esm2({
   "src/lib/parsers/parse-commit.ts"() {
     init_utils();
     parsers = [
@@ -226635,7 +227091,7 @@ function commit_default() {
     return !filterStringOrStringArray(message) && configurationErrorTask(`git.commit: requires the commit message to be supplied as a string/string[]`);
   }
 }
-var init_commit = __esm({
+var init_commit = __esm2({
   "src/lib/tasks/commit.ts"() {
     init_parse_commit();
     init_utils();
@@ -226649,7 +227105,7 @@ function first_commit_default() {
     }
   };
 }
-var init_first_commit = __esm({
+var init_first_commit = __esm2({
   "src/lib/tasks/first-commit.ts"() {
     init_utils();
     init_task();
@@ -226662,19 +227118,19 @@ function hashObjectTask(filePath, write) {
   }
   return straightThroughStringTask(commands, true);
 }
-var init_hash_object = __esm({
+var init_hash_object = __esm2({
   "src/lib/tasks/hash-object.ts"() {
     init_task();
   }
 });
-function parseInit(bare, path4, text) {
+function parseInit(bare, path3, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path4, false, result[1]);
+    return new InitSummary(bare, path3, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path4, true, result[1]);
+    return new InitSummary(bare, path3, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -226685,17 +227141,17 @@ function parseInit(bare, path4, text) {
       break;
     }
   }
-  return new InitSummary(bare, path4, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path3, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
 var reInitResponseRegex;
-var init_InitSummary = __esm({
+var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     InitSummary = class {
-      constructor(bare, path4, existing, gitDir) {
+      constructor(bare, path3, existing, gitDir) {
         this.bare = bare;
-        this.path = path4;
+        this.path = path3;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -226707,7 +227163,7 @@ var init_InitSummary = __esm({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path4, customArgs) {
+function initTask(bare = false, path3, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -226716,12 +227172,12 @@ function initTask(bare = false, path4, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path4, text);
+      return parseInit(commands.includes("--bare"), path3, text);
     }
   };
 }
 var bareCommand;
-var init_init = __esm({
+var init_init = __esm2({
   "src/lib/tasks/init.ts"() {
     init_InitSummary();
     bareCommand = "--bare";
@@ -226740,13 +227196,13 @@ function isLogFormat(customArg) {
   return logFormatRegex.test(customArg);
 }
 var logFormatRegex;
-var init_log_format = __esm({
+var init_log_format = __esm2({
   "src/lib/args/log-format.ts"() {
     logFormatRegex = /^--(stat|numstat|name-only|name-status)(=|$)/;
   }
 });
 var DiffSummary;
-var init_DiffSummary = __esm({
+var init_DiffSummary = __esm2({
   "src/lib/responses/DiffSummary.ts"() {
     DiffSummary = class {
       constructor() {
@@ -226767,7 +227223,7 @@ var numStatParser;
 var nameOnlyParser;
 var nameStatusParser;
 var diffSummaryParsers;
-var init_parse_diff_summary = __esm({
+var init_parse_diff_summary = __esm2({
   "src/lib/parsers/parse-diff-summary.ts"() {
     init_log_format();
     init_DiffSummary();
@@ -226888,7 +227344,7 @@ var START_BOUNDARY;
 var COMMIT_BOUNDARY;
 var SPLITTER;
 var defaultFieldNames;
-var init_parse_list_log_summary = __esm({
+var init_parse_list_log_summary = __esm2({
   "src/lib/parsers/parse-list-log-summary.ts"() {
     init_utils();
     init_parse_diff_summary();
@@ -226927,7 +227383,7 @@ function validateLogFormatConfig(customArgs) {
     return configurationErrorTask(`Summary flag ${flags} parsing is not compatible with null termination option '-z'`);
   }
 }
-var init_diff = __esm({
+var init_diff = __esm2({
   "src/lib/tasks/diff.ts"() {
     init_log_format();
     init_parse_diff_summary();
@@ -227011,7 +227467,7 @@ function log_default() {
   }
 }
 var excludeOptions;
-var init_log = __esm({
+var init_log = __esm2({
   "src/lib/tasks/log.ts"() {
     init_log_format();
     init_pathspec();
@@ -227039,7 +227495,7 @@ var init_log = __esm({
 });
 var MergeSummaryConflict;
 var MergeSummaryDetail;
-var init_MergeSummary = __esm({
+var init_MergeSummary = __esm2({
   "src/lib/responses/MergeSummary.ts"() {
     MergeSummaryConflict = class {
       constructor(reason, file = null, meta) {
@@ -227074,7 +227530,7 @@ var init_MergeSummary = __esm({
 });
 var PullSummary;
 var PullFailedSummary;
-var init_PullSummary = __esm({
+var init_PullSummary = __esm2({
   "src/lib/responses/PullSummary.ts"() {
     PullSummary = class {
       constructor() {
@@ -227131,7 +227587,7 @@ function asObjectCount(source) {
   };
 }
 var remoteMessagesObjectParsers;
-var init_parse_remote_objects = __esm({
+var init_parse_remote_objects = __esm2({
   "src/lib/parsers/parse-remote-objects.ts"() {
     init_utils();
     remoteMessagesObjectParsers = [
@@ -227159,7 +227615,7 @@ function parseRemoteMessages(_stdOut, stdErr) {
 }
 var parsers2;
 var RemoteMessageSummary;
-var init_parse_remote_messages = __esm({
+var init_parse_remote_messages = __esm2({
   "src/lib/parsers/parse-remote-messages.ts"() {
     init_utils();
     init_parse_remote_objects();
@@ -227198,7 +227654,7 @@ var parsers3;
 var errorParsers;
 var parsePullDetail;
 var parsePullResult;
-var init_parse_pull = __esm({
+var init_parse_pull = __esm2({
   "src/lib/parsers/parse-pull.ts"() {
     init_PullSummary();
     init_utils();
@@ -227251,7 +227707,7 @@ var init_parse_pull = __esm({
 var parsers4;
 var parseMergeResult;
 var parseMergeDetail;
-var init_parse_merge = __esm({
+var init_parse_merge = __esm2({
   "src/lib/parsers/parse-merge.ts"() {
     init_MergeSummary();
     init_utils();
@@ -227297,7 +227753,7 @@ function mergeTask(customArgs) {
     }
   };
 }
-var init_merge = __esm({
+var init_merge = __esm2({
   "src/lib/tasks/merge.ts"() {
     init_git_response_error();
     init_parse_merge();
@@ -227321,7 +227777,7 @@ function pushResultPushedItem(local, remote, status) {
 var parsers5;
 var parsePushResult;
 var parsePushDetail;
-var init_parse_push = __esm({
+var init_parse_push = __esm2({
   "src/lib/parsers/parse-push.ts"() {
     init_utils();
     init_parse_remote_messages();
@@ -227398,7 +227854,7 @@ function pushTask(ref = {}, customArgs) {
     parser: parsePushResult
   };
 }
-var init_push = __esm({
+var init_push = __esm2({
   "src/lib/tasks/push.ts"() {
     init_parse_push();
     init_utils();
@@ -227419,7 +227875,7 @@ function show_default() {
     }
   };
 }
-var init_show = __esm({
+var init_show = __esm2({
   "src/lib/tasks/show.ts"() {
     init_utils();
     init_task();
@@ -227427,16 +227883,16 @@ var init_show = __esm({
 });
 var fromPathRegex;
 var FileStatusSummary;
-var init_FileStatusSummary = __esm({
+var init_FileStatusSummary = __esm2({
   "src/lib/responses/FileStatusSummary.ts"() {
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path4, index, working_dir) {
-        this.path = path4;
+      constructor(path3, index, working_dir) {
+        this.path = path3;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path4) || [null, path4, path4];
+          const detail = fromPathRegex.exec(path3) || [null, path3, path3];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -227467,21 +227923,21 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path4) {
+  function data(index, workingDir, path3) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path4);
+      handler(result, path3);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path4, index, workingDir));
+      result.files.push(new FileStatusSummary(path3, index, workingDir));
     }
   }
 }
 var StatusSummary;
 var parsers6;
 var parseStatusSummary;
-var init_StatusSummary = __esm({
+var init_StatusSummary = __esm2({
   "src/lib/responses/StatusSummary.ts"() {
     init_utils();
     init_FileStatusSummary();
@@ -227588,7 +228044,7 @@ function statusTask(customArgs) {
   };
 }
 var ignoredOptions;
-var init_status = __esm({
+var init_status = __esm2({
   "src/lib/tasks/status.ts"() {
     init_StatusSummary();
     ignoredOptions = ["--null", "-z"];
@@ -227637,7 +228093,7 @@ function versionParser(stdOut) {
 }
 var NOT_INSTALLED;
 var parsers7;
-var init_version = __esm({
+var init_version = __esm2({
   "src/lib/tasks/version.ts"() {
     init_utils();
     NOT_INSTALLED = "installed=false";
@@ -227656,7 +228112,7 @@ __export2(simple_git_api_exports, {
   SimpleGitApi: () => SimpleGitApi
 });
 var SimpleGitApi;
-var init_simple_git_api = __esm({
+var init_simple_git_api = __esm2({
   "src/lib/simple-git-api.ts"() {
     init_task_callback();
     init_change_working_directory();
@@ -227705,8 +228161,8 @@ var init_simple_git_api = __esm({
         }
         return this._runTask(configurationErrorTask("Git.cwd: workingDirectory must be supplied as a string"), next);
       }
-      hashObject(path4, write) {
-        return this._runTask(hashObjectTask(path4, write === true), trailingFunctionArgument(arguments));
+      hashObject(path3, write) {
+        return this._runTask(hashObjectTask(path3, write === true), trailingFunctionArgument(arguments));
       }
       init(bare) {
         return this._runTask(initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
@@ -227747,7 +228203,7 @@ __export2(scheduler_exports, {
 });
 var createScheduledTask;
 var Scheduler;
-var init_scheduler = __esm({
+var init_scheduler = __esm2({
   "src/lib/runners/scheduler.ts"() {
     init_utils();
     init_git_logger();
@@ -227800,7 +228256,7 @@ __export2(apply_patch_exports, {
 function applyPatchTask(patches, customArgs) {
   return straightThroughStringTask(["apply", ...customArgs, ...patches]);
 }
-var init_apply_patch = __esm({
+var init_apply_patch = __esm2({
   "src/lib/tasks/apply-patch.ts"() {
     init_task();
   }
@@ -227820,7 +228276,7 @@ function branchDeletionFailure(branch) {
   };
 }
 var BranchDeletionBatch;
-var init_BranchDeleteSummary = __esm({
+var init_BranchDeleteSummary = __esm2({
   "src/lib/responses/BranchDeleteSummary.ts"() {
     BranchDeletionBatch = class {
       constructor() {
@@ -227841,7 +228297,7 @@ var deleteSuccessRegex;
 var deleteErrorRegex;
 var parsers8;
 var parseBranchDeletions;
-var init_parse_branch_delete = __esm({
+var init_parse_branch_delete = __esm2({
   "src/lib/parsers/parse-branch-delete.ts"() {
     init_BranchDeleteSummary();
     init_utils();
@@ -227866,7 +228322,7 @@ var init_parse_branch_delete = __esm({
   }
 });
 var BranchSummaryResult;
-var init_BranchSummary = __esm({
+var init_BranchSummary = __esm2({
   "src/lib/responses/BranchSummary.ts"() {
     BranchSummaryResult = class {
       constructor() {
@@ -227899,7 +228355,7 @@ function parseBranchSummary(stdOut) {
   return parseStringResponse(new BranchSummaryResult, parsers9, stdOut);
 }
 var parsers9;
-var init_parse_branch = __esm({
+var init_parse_branch = __esm2({
   "src/lib/parsers/parse-branch.ts"() {
     init_BranchSummary();
     init_utils();
@@ -227984,7 +228440,7 @@ function deleteBranchTask(branch, forceDelete = false) {
   };
   return task;
 }
-var init_branch = __esm({
+var init_branch = __esm2({
   "src/lib/tasks/branch.ts"() {
     init_git_response_error();
     init_parse_branch_delete();
@@ -227993,7 +228449,7 @@ var init_branch = __esm({
   }
 });
 var parseCheckIgnore;
-var init_CheckIgnore = __esm({
+var init_CheckIgnore = __esm2({
   "src/lib/responses/CheckIgnore.ts"() {
     parseCheckIgnore = (text) => {
       return text.split(/\n/g).map((line) => line.trim()).filter((file) => !!file);
@@ -228011,7 +228467,7 @@ function checkIgnoreTask(paths) {
     parser: parseCheckIgnore
   };
 }
-var init_check_ignore = __esm({
+var init_check_ignore = __esm2({
   "src/lib/tasks/check-ignore.ts"() {
     init_CheckIgnore();
   }
@@ -228038,7 +228494,7 @@ function cloneMirrorTask(repo, directory, customArgs) {
   append2(customArgs, "--mirror");
   return cloneTask(repo, directory, customArgs);
 }
-var init_clone = __esm({
+var init_clone = __esm2({
   "src/lib/tasks/clone.ts"() {
     init_task();
     init_utils();
@@ -228056,7 +228512,7 @@ function parseFetchResult(stdOut, stdErr) {
   return parseStringResponse(result, parsers10, [stdOut, stdErr]);
 }
 var parsers10;
-var init_parse_fetch = __esm({
+var init_parse_fetch = __esm2({
   "src/lib/parsers/parse-fetch.ts"() {
     init_utils();
     parsers10 = [
@@ -228113,7 +228569,7 @@ function fetchTask(remote, branch, customArgs) {
     parser: parseFetchResult
   };
 }
-var init_fetch = __esm({
+var init_fetch = __esm2({
   "src/lib/tasks/fetch.ts"() {
     init_parse_fetch();
     init_task();
@@ -228123,7 +228579,7 @@ function parseMoveResult(stdOut) {
   return parseStringResponse({ moves: [] }, parsers11, stdOut);
 }
 var parsers11;
-var init_parse_move = __esm({
+var init_parse_move = __esm2({
   "src/lib/parsers/parse-move.ts"() {
     init_utils();
     parsers11 = [
@@ -228144,7 +228600,7 @@ function moveTask(from, to) {
     parser: parseMoveResult
   };
 }
-var init_move = __esm({
+var init_move = __esm2({
   "src/lib/tasks/move.ts"() {
     init_parse_move();
     init_utils();
@@ -228174,7 +228630,7 @@ function pullTask(remote, branch, customArgs) {
     }
   };
 }
-var init_pull = __esm({
+var init_pull = __esm2({
   "src/lib/tasks/pull.ts"() {
     init_git_response_error();
     init_parse_pull();
@@ -228204,7 +228660,7 @@ function parseGetRemotesVerbose(text) {
 function forEach2(text, handler) {
   forEachLineWithContent(text, (line) => handler(line.split(/\s+/)));
 }
-var init_GetRemoteSummary = __esm({
+var init_GetRemoteSummary = __esm2({
   "src/lib/responses/GetRemoteSummary.ts"() {
     init_utils();
   }
@@ -228248,7 +228704,7 @@ function remoteTask(customArgs) {
 function removeRemoteTask(remoteName) {
   return straightThroughStringTask(["remote", "remove", remoteName]);
 }
-var init_remote = __esm({
+var init_remote = __esm2({
   "src/lib/tasks/remote.ts"() {
     init_GetRemoteSummary();
     init_task();
@@ -228268,7 +228724,7 @@ function stashListTask(opt = {}, customArgs) {
     parser: parser4
   };
 }
-var init_stash_list = __esm({
+var init_stash_list = __esm2({
   "src/lib/tasks/stash-list.ts"() {
     init_log_format();
     init_parse_list_log_summary();
@@ -228283,8 +228739,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path4) {
-  return subModuleTask(["add", repo, path4]);
+function addSubModuleTask(repo, path3) {
+  return subModuleTask(["add", repo, path3]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -228299,7 +228755,7 @@ function subModuleTask(customArgs) {
 function updateSubModuleTask(customArgs) {
   return subModuleTask(["update", ...customArgs]);
 }
-var init_sub_module = __esm({
+var init_sub_module = __esm2({
   "src/lib/tasks/sub-module.ts"() {
     init_task();
   }
@@ -228326,7 +228782,7 @@ function toNumber(input) {
 }
 var TagList;
 var parseTagList;
-var init_TagList = __esm({
+var init_TagList = __esm2({
   "src/lib/responses/TagList.ts"() {
     TagList = class {
       constructor(all3, latest) {
@@ -228392,7 +228848,7 @@ function addAnnotatedTagTask(name, tagMessage) {
     }
   };
 }
-var init_tag = __esm({
+var init_tag = __esm2({
   "src/lib/tasks/tag.ts"() {
     init_TagList();
   }
@@ -228552,8 +229008,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path4, then) {
-      return this._runTask(addSubModuleTask2(repo, path4), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path3, then) {
+      return this._runTask(addSubModuleTask2(repo, path3), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(updateSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
@@ -229068,10 +229524,12 @@ var esm_default2 = gitInstanceFactory;
 import { Writable } from "stream";
 
 // src/config.ts
+init_constants();
+init_logger();
 import fs2 from "fs";
-import path4 from "path";
+import path3 from "path";
 import { fileURLToPath } from "url";
-var BUNDLED_DEFAULT_CONFIG_PATH = path4.join(path4.dirname(fileURLToPath(import.meta.url)), "default-publisher.config.json");
+var BUNDLED_DEFAULT_CONFIG_PATH = path3.join(path3.dirname(fileURLToPath(import.meta.url)), "default-publisher.config.json");
 function resolvePublisherConfigPath(serverRoot) {
   const explicitPath = process.env.PUBLISHER_CONFIG_PATH;
   if (explicitPath && explicitPath.length > 0) {
@@ -229080,7 +229538,7 @@ function resolvePublisherConfigPath(serverRoot) {
     }
     return { path: explicitPath, isBundledDefault: false };
   }
-  const serverRootPath = path4.join(serverRoot, PUBLISHER_CONFIG_NAME);
+  const serverRootPath = path3.join(serverRoot, PUBLISHER_CONFIG_NAME);
   if (fs2.existsSync(serverRootPath)) {
     return { path: serverRootPath, isBundledDefault: false };
   }
@@ -229089,6 +229547,73 @@ function resolvePublisherConfigPath(serverRoot) {
   }
   return null;
 }
+var DEFAULT_HIGH_WATER_FRACTION = 0.8;
+var DEFAULT_LOW_WATER_FRACTION = 0.7;
+var DEFAULT_CHECK_INTERVAL_MS = 5000;
+var MIN_CHECK_INTERVAL_MS = 100;
+function parseIntEnv(name) {
+  const raw = process.env[name];
+  if (raw === undefined || raw.trim() === "")
+    return;
+  const value = Number.parseInt(raw, 10);
+  if (!Number.isFinite(value) || String(value) !== raw.trim()) {
+    throw new Error(`Invalid value for ${name}: expected a base-10 integer, got "${raw}"`);
+  }
+  return value;
+}
+function parseFloatEnv(name) {
+  const raw = process.env[name];
+  if (raw === undefined || raw.trim() === "")
+    return;
+  const value = Number.parseFloat(raw);
+  if (!Number.isFinite(value)) {
+    throw new Error(`Invalid value for ${name}: expected a finite number, got "${raw}"`);
+  }
+  return value;
+}
+function parseBoolEnv(name) {
+  const raw = process.env[name];
+  if (raw === undefined || raw.trim() === "")
+    return;
+  const normalised = raw.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalised))
+    return true;
+  if (["0", "false", "no", "off"].includes(normalised))
+    return false;
+  throw new Error(`Invalid value for ${name}: expected a boolean (true/false), got "${raw}"`);
+}
+var getMemoryGovernorConfig = () => {
+  const maxMemoryBytes = parseIntEnv("PUBLISHER_MAX_MEMORY_BYTES");
+  if (maxMemoryBytes === undefined || maxMemoryBytes === 0) {
+    return null;
+  }
+  if (maxMemoryBytes < 0) {
+    throw new Error(`PUBLISHER_MAX_MEMORY_BYTES must be a positive integer (got ${maxMemoryBytes})`);
+  }
+  const highWaterFraction = parseFloatEnv("PUBLISHER_MEMORY_HIGH_WATER_FRACTION") ?? DEFAULT_HIGH_WATER_FRACTION;
+  const lowWaterFraction = parseFloatEnv("PUBLISHER_MEMORY_LOW_WATER_FRACTION") ?? DEFAULT_LOW_WATER_FRACTION;
+  const checkIntervalMs = parseIntEnv("PUBLISHER_MEMORY_CHECK_INTERVAL_MS") ?? DEFAULT_CHECK_INTERVAL_MS;
+  const backpressureEnabled = parseBoolEnv("PUBLISHER_MEMORY_BACKPRESSURE") ?? true;
+  if (highWaterFraction <= 0 || highWaterFraction >= 1) {
+    throw new Error(`PUBLISHER_MEMORY_HIGH_WATER_FRACTION must be in (0, 1) (got ${highWaterFraction})`);
+  }
+  if (lowWaterFraction <= 0 || lowWaterFraction >= 1) {
+    throw new Error(`PUBLISHER_MEMORY_LOW_WATER_FRACTION must be in (0, 1) (got ${lowWaterFraction})`);
+  }
+  if (lowWaterFraction >= highWaterFraction) {
+    throw new Error(`PUBLISHER_MEMORY_LOW_WATER_FRACTION (${lowWaterFraction}) must be strictly less than PUBLISHER_MEMORY_HIGH_WATER_FRACTION (${highWaterFraction})`);
+  }
+  if (checkIntervalMs < MIN_CHECK_INTERVAL_MS) {
+    throw new Error(`PUBLISHER_MEMORY_CHECK_INTERVAL_MS must be >= ${MIN_CHECK_INTERVAL_MS} (got ${checkIntervalMs})`);
+  }
+  return {
+    maxMemoryBytes,
+    highWaterFraction,
+    lowWaterFraction,
+    checkIntervalMs,
+    backpressureEnabled
+  };
+};
 function substituteEnvVars(value) {
   const envVarPattern = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
   return value.replace(envVarPattern, (_match, varName) => {
@@ -229128,7 +229653,7 @@ var getPublisherConfig = (serverRoot) => {
   }
   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.`);
+    logger.info(`No publisher.config.json found at ${path3.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 {
@@ -229258,7 +229783,12 @@ var getProcessedPublisherConfig = (serverRoot) => {
   };
 };
 
+// src/service/environment_store.ts
+init_constants();
+init_errors();
+
 // src/health.ts
+init_logger();
 var operationalState = "initializing";
 var ready = false;
 var preGracefulShutdownCompleted = false;
@@ -229274,15 +229804,6 @@ 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");
@@ -229297,37 +229818,45 @@ function registerSignalHandlers(server, mcpServer, shutdownDrainDurationSeconds
       preGracefulShutdownCompleted = true;
       resolve3(true);
     }, shutdownDrainDurationSeconds * 1000));
-    const closeServer = (server2, name) => new Promise((resolve3) => {
-      if (server2 && server2.listening) {
-        server2.close((err) => {
-          if (err) {
-            logger.error(`${name} close error:`, err);
-          } else {
-            logger.info(`${name} closed`);
-          }
-          resolve3();
-        });
-      } else {
+    await performGracefulShutdownAfterDrain(server, mcpServer, shutdownGracefulCloseTimeoutSeconds);
+  });
+}
+async function performGracefulShutdownAfterDrain(server, mcpServer, shutdownGracefulCloseTimeoutSeconds) {
+  const closeServer = (server2, name) => new Promise((resolve3) => {
+    if (server2 && server2.listening) {
+      server2.close((err) => {
+        if (err) {
+          logger.error(`${name} close error:`, err);
+        } else {
+          logger.info(`${name} closed`);
+        }
         resolve3();
-      }
-    });
-    await Promise.all([
-      closeServer(server, "Main server"),
-      closeServer(mcpServer, "MCP server")
-    ]);
-    try {
-      await shutdownSDK();
-      logger.info("OpenTelemetry SDK shut down");
-    } catch (_error) {}
-    try {
-      logger.close();
-    } catch (_error) {}
-    if (shutdownGracefulCloseTimeoutSeconds > 0) {
-      logger.info(`Waiting ${shutdownGracefulCloseTimeoutSeconds} seconds after server close before exit...`);
-      await new Promise((resolve3) => setTimeout(resolve3, shutdownGracefulCloseTimeoutSeconds * 1000));
+      });
+    } else {
+      resolve3();
     }
-    process.exit(0);
   });
+  await Promise.all([
+    closeServer(server, "Main server"),
+    closeServer(mcpServer, "MCP server")
+  ]);
+  try {
+    await shutdownSDK();
+    logger.info("OpenTelemetry SDK shut down");
+  } catch (_error) {}
+  try {
+    const { getCompilePool: getCompilePool2 } = await Promise.resolve().then(() => (init_compile_pool(), exports_compile_pool));
+    await getCompilePool2().shutdown();
+    logger.info("Malloy compile worker pool shut down");
+  } catch (_error) {}
+  if (shutdownGracefulCloseTimeoutSeconds > 0) {
+    logger.info(`Waiting ${shutdownGracefulCloseTimeoutSeconds} seconds after server close before exit...`);
+    await new Promise((resolve3) => setTimeout(resolve3, shutdownGracefulCloseTimeoutSeconds * 1000));
+  }
+  try {
+    logger.close();
+  } catch (_error) {}
+  process.exit(0);
 }
 function drainingGuard(req, res, next) {
   if (operationalState === "draining" && preGracefulShutdownCompleted && !req.path.startsWith("/health") && !req.path.startsWith("/metrics")) {
@@ -229361,12 +229890,17 @@ function registerHealthEndpoints(app) {
   });
 }
 
+// src/service/environment_store.ts
+init_logger();
+
 // src/storage/StorageManager.ts
+init_errors();
+init_logger();
 import * as crypto3 from "crypto";
 
 // src/storage/duckdb/DuckDBConnection.ts
 import duckdb from "duckdb";
-import * as path5 from "path";
+import * as path4 from "path";
 
 class DuckDBConnection2 {
   db = null;
@@ -229374,7 +229908,7 @@ class DuckDBConnection2 {
   dbPath;
   mutex = new Mutex;
   constructor(dbPath) {
-    this.dbPath = dbPath || path5.join(process.cwd(), "publisher.db");
+    this.dbPath = dbPath || path4.join(process.cwd(), "publisher.db");
   }
   async initialize() {
     return new Promise((resolve3, reject) => {
@@ -230168,6 +230702,7 @@ class DuckDBRepository {
 }
 
 // src/storage/duckdb/schema.ts
+init_logger();
 async function initializeSchema(db, force = false) {
   const initialized = await db.isInitialized();
   if (initialized && !force) {
@@ -230296,6 +230831,8 @@ async function dropAllTables(db) {
 }
 
 // src/storage/ducklake/DuckLakeManifestStore.ts
+init_logger();
+
 class DuckLakeManifestStore {
   db;
   table;
@@ -230523,18 +231060,75 @@ class StorageManager {
 
 // src/service/environment.ts
 import { MalloyError as MalloyError3, Runtime as Runtime2 } from "@malloydata/malloy";
+init_constants();
+init_errors();
+init_logger();
+import crypto4 from "crypto";
 import * as fs6 from "fs";
 import * as path9 from "path";
 
+// src/path_safety.ts
+init_errors();
+import * as path5 from "path";
+var SAFE_NAME_RE = /^(?!\.\.?$)(?!\.)[A-Za-z0-9._-]{1,255}$/;
+var MAX_MODEL_PATH_LEN = 1024;
+var SAFE_ENVIRONMENT_PATH_RE = /^(?:\/|[A-Za-z]:[\\/])[\x20-\x7E]*$/;
+var MAX_ENVIRONMENT_PATH_LEN = 4096;
+function assertSafePackageName(packageName) {
+  if (typeof packageName !== "string" || !SAFE_NAME_RE.test(packageName)) {
+    throw new BadRequestError(`Invalid package name: must be 1-255 characters of letters, digits, "-", "_", or "." and must not start with "."`);
+  }
+}
+function assertSafeRelativeModelPath(modelPath) {
+  if (typeof modelPath !== "string" || modelPath.length === 0 || modelPath.length > MAX_MODEL_PATH_LEN || modelPath.includes("\x00") || modelPath.includes("\\") || path5.isAbsolute(modelPath) || modelPath.startsWith("/")) {
+    throw new BadRequestError(`Invalid model path`);
+  }
+  const segments = modelPath.split("/");
+  for (const segment of segments) {
+    if (segment === "" || segment === "." || segment === "..") {
+      throw new BadRequestError(`Invalid model path`);
+    }
+    if (segment.startsWith(".")) {
+      throw new BadRequestError(`Invalid model path`);
+    }
+  }
+}
+function assertSafeEnvironmentPath(environmentPath) {
+  if (typeof environmentPath !== "string") {
+    throw new BadRequestError(`Invalid environment path: must be a string`);
+  }
+  if (environmentPath.length === 0 || environmentPath.length > MAX_ENVIRONMENT_PATH_LEN) {
+    throw new BadRequestError(`Invalid environment path: bad length`);
+  }
+  if (environmentPath.indexOf("\x00") !== -1) {
+    throw new BadRequestError(`Invalid environment path: contains NUL byte`);
+  }
+  if (environmentPath.indexOf("..") !== -1) {
+    throw new BadRequestError(`Invalid environment path: contains ".." traversal segment`);
+  }
+  if (!SAFE_ENVIRONMENT_PATH_RE.test(environmentPath)) {
+    throw new BadRequestError(`Invalid environment path: must be an absolute path of printable ASCII characters`);
+  }
+}
+function safeJoinUnderRoot(root, ...segments) {
+  const resolvedRoot = path5.resolve(root);
+  const joined = path5.resolve(resolvedRoot, ...segments);
+  const rootWithSep = resolvedRoot.endsWith(path5.sep) ? resolvedRoot : resolvedRoot + path5.sep;
+  if (joined !== resolvedRoot && !joined.startsWith(rootWithSep)) {
+    throw new BadRequestError(`Resolved path is outside of root`);
+  }
+  return joined;
+}
+
 // src/utils.ts
 import * as fs3 from "fs";
 import * as path6 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var URL_READER = {
   readURL: (url2) => {
     let path7 = url2.toString();
     if (url2.protocol == "file:") {
-      path7 = fileURLToPath2(url2);
+      path7 = fileURLToPath3(url2);
     }
     return fs3.promises.readFile(path7, "utf8");
   }
@@ -230544,6 +231138,9 @@ function ignoreDotfiles(file) {
 }
 
 // src/service/package.ts
+init_constants();
+init_errors();
+init_logger();
 var import_api3 = __toESM(require_src(), 1);
 var import_recursive_readdir = __toESM(require_recursive_readdir(), 1);
 import * as fs5 from "fs/promises";
@@ -230559,6 +231156,8 @@ import {
 } from "@malloydata/malloy";
 
 // src/service/model.ts
+init_compile_pool();
+init_constants();
 var import_api2 = __toESM(require_src(), 1);
 import {
   API,
@@ -230578,6 +231177,7 @@ import { createRequire as createRequire2 } from "module";
 import * as path7 from "path";
 
 // src/data_styles.ts
+init_logger();
 function compileDataStyles(styles) {
   try {
     return JSON.parse(styles);
@@ -230624,6 +231224,10 @@ class HackyDataStylesAccumulator {
   }
 }
 
+// src/service/model.ts
+init_errors();
+init_logger();
+
 // src/service/filter.ts
 var VALID_FILTER_TYPES = new Set([
   "equal",
@@ -230816,6 +231420,15 @@ function tokenize(input) {
 
 // src/service/model.ts
 var MALLOY_VERSION = createRequire2(import.meta.url)("@malloydata/malloy/package.json").version;
+function malloyGivenToApi(given) {
+  const type = given.type;
+  const renderedType = type.type === "filter expression" ? `filter<${type.filterType}>` : type.type;
+  return {
+    name: given.name,
+    type: renderedType,
+    annotations: given.getTaglines(/^#\(/)
+  };
+}
 
 class Model {
   packageName;
@@ -230823,6 +231436,8 @@ class Model {
   dataStyles;
   modelType;
   modelMaterializer;
+  materializerBuilder;
+  materializerBuildPromise;
   modelDef;
   modelInfo;
   sources;
@@ -230831,26 +231446,44 @@ class Model {
   runnableNotebookCells;
   compilationError;
   filterMap;
+  givens;
+  cachedStandardModel;
   meter = import_api2.metrics.getMeter("publisher");
   queryExecutionHistogram = this.meter.createHistogram("malloy_model_query_duration", {
     description: "How long it takes to execute a Malloy model query",
     unit: "ms"
   });
-  constructor(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, sourceInfos, runnableNotebookCells, compilationError, filterMap) {
+  constructor(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, sourceInfos, runnableNotebookCells, compilationError, filterMap, givens, materializerBuilder) {
     this.packageName = packageName;
     this.modelPath = modelPath;
     this.dataStyles = dataStyles;
     this.modelType = modelType;
     this.modelDef = modelDef;
     this.modelMaterializer = modelMaterializer;
+    this.materializerBuilder = materializerBuilder;
     this.sources = sources;
     this.queries = queries;
     this.sourceInfos = sourceInfos;
     this.runnableNotebookCells = runnableNotebookCells;
     this.compilationError = compilationError;
     this.filterMap = filterMap ?? new Map;
+    this.givens = givens;
     this.modelInfo = this.modelDef ? modelDefToModelInfo(this.modelDef) : undefined;
   }
+  async ensureMaterializer() {
+    if (this.modelMaterializer)
+      return this.modelMaterializer;
+    if (!this.materializerBuilder) {
+      throw new BadRequestError("Model has no queryable entities.");
+    }
+    if (!this.materializerBuildPromise) {
+      this.materializerBuildPromise = this.materializerBuilder().then((mm) => {
+        this.modelMaterializer = mm;
+        return mm;
+      });
+    }
+    return this.materializerBuildPromise;
+  }
   getFilters(sourceName) {
     return this.filterMap.get(sourceName) ?? [];
   }
@@ -230862,6 +231495,40 @@ class Model {
     return runMatch?.[1] ?? arrowMatch?.[1];
   }
   static async create(packageName, packagePath, modelPath, malloyConfig, options) {
+    const pool = getCompilePool();
+    if (pool.enabled && modelPath.endsWith(MODEL_FILE_SUFFIX)) {
+      try {
+        return await Model.createViaWorker(packageName, packagePath, modelPath, malloyConfig, pool, options);
+      } catch (poolError) {
+        if (poolError instanceof ModelCompilationError || poolError instanceof MalloyError2) {
+          return Model.makeErrorModel(packageName, modelPath, poolError instanceof MalloyError2 ? new ModelCompilationError(poolError) : poolError);
+        }
+        logger.warn("Compile worker failed; falling back to in-process compile", { packageName, modelPath, error: poolError });
+      }
+    }
+    return Model.createInProcess(packageName, packagePath, modelPath, malloyConfig, options);
+  }
+  static async createViaWorker(packageName, packagePath, modelPath, malloyConfig, pool, options) {
+    const resolvedConfig = Model.toMalloyConfig(malloyConfig);
+    const outcome = await pool.compile({
+      packagePath,
+      modelPath,
+      malloyConfig: resolvedConfig,
+      defaultConnectionName: "duckdb",
+      urlReader: URL_READER,
+      buildManifest: options?.buildManifest
+    });
+    const materializerBuilder = async () => {
+      const { runtime, modelURL, importBaseURL } = await Model.getModelRuntime(packagePath, modelPath, malloyConfig, options);
+      return Model.getStandardModelMaterializer(runtime, importBaseURL, modelURL, modelPath);
+    };
+    return new Model(packageName, modelPath, {}, "model", undefined, outcome.modelDef, outcome.sources, outcome.queries, outcome.sourceInfos.length > 0 ? outcome.sourceInfos : undefined, undefined, undefined, outcome.filterMap, outcome.givens, materializerBuilder);
+  }
+  static makeErrorModel(packageName, modelPath, error) {
+    const isNotebook = modelPath.endsWith(NOTEBOOK_FILE_SUFFIX);
+    return new Model(packageName, modelPath, {}, isNotebook ? "notebook" : "model", undefined, undefined, undefined, undefined, undefined, undefined, error);
+  }
+  static async createInProcess(packageName, packagePath, modelPath, malloyConfig, options) {
     const { runtime, modelURL, importBaseURL, dataStyles, modelType } = await Model.getModelRuntime(packagePath, modelPath, malloyConfig, options);
     try {
       const { modelMaterializer, runnableNotebookCells } = await Model.getModelMaterializer(runtime, importBaseURL, modelURL, modelPath);
@@ -230869,10 +231536,14 @@ class Model {
       let sources = undefined;
       let queries = undefined;
       let filterMap;
+      let givens;
       const sourceInfos = [];
       if (modelMaterializer) {
-        modelDef = (await modelMaterializer.getModel())._modelDef;
-        const sourceResult = Model.getSources(modelPath, modelDef);
+        const compiledModel = await modelMaterializer.getModel();
+        modelDef = compiledModel._modelDef;
+        const malloyGivens = Array.from(compiledModel.givens.values());
+        givens = malloyGivens.length > 0 ? malloyGivens.map(malloyGivenToApi) : undefined;
+        const sourceResult = Model.getSources(modelPath, modelDef, givens);
         sources = sourceResult.sources;
         filterMap = sourceResult.filterMap;
         queries = Model.getQueries(modelPath, modelDef);
@@ -230905,7 +231576,7 @@ class Model {
           }
         }
       }
-      return new Model(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, sourceInfos.length > 0 ? sourceInfos : undefined, runnableNotebookCells, undefined, filterMap);
+      return new Model(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, sourceInfos.length > 0 ? sourceInfos : undefined, runnableNotebookCells, undefined, filterMap, givens);
     } catch (error) {
       let computedError = error;
       if (error instanceof Error && error.stack) {
@@ -230959,7 +231630,7 @@ class Model {
       throw new ModelNotFoundError(`${this.modelPath} is not a valid notebook name.  Notebook files must end in .malloynb.`);
     }
   }
-  async getQueryResults(sourceName, queryName, query, filterParams, bypassFilters) {
+  async getQueryResults(sourceName, queryName, query, filterParams, bypassFilters, givens) {
     const startTime = performance.now();
     if (this.compilationError) {
       if (this.compilationError instanceof MalloyError2 || this.compilationError instanceof ModelCompilationError) {
@@ -230968,8 +231639,18 @@ class Model {
       throw new BadRequestError(`Model compilation failed: ${this.compilationError.message}`);
     }
     let runnable;
-    if (!this.modelMaterializer || !this.modelDef || !this.modelInfo)
+    if (!this.modelDef || !this.modelInfo)
       throw new BadRequestError("Model has no queryable entities.");
+    let materializer;
+    try {
+      materializer = await this.ensureMaterializer();
+    } catch (error) {
+      if (error instanceof BadRequestError)
+        throw error;
+      if (error instanceof MalloyError2)
+        throw error;
+      throw new BadRequestError(error instanceof Error ? `Failed to prepare model: ${error.message}` : "Failed to prepare model.");
+    }
     try {
       let queryString;
       if (!sourceName && !queryName && query) {
@@ -231000,7 +231681,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
           }
         }
       }
-      runnable = this.modelMaterializer.loadQuery(queryString);
+      runnable = materializer.loadQuery(queryString);
     } catch (error) {
       if (error instanceof BadRequestError) {
         throw error;
@@ -231023,12 +231704,12 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       });
       throw new BadRequestError(`Invalid query: ${errorMessage}`);
     }
-    const rowLimit = (await runnable.getPreparedResult()).resultExplore.limit || ROW_LIMIT;
+    const rowLimit = (await runnable.getPreparedResult({ givens })).resultExplore.limit || ROW_LIMIT;
     const endTime = performance.now();
     const executionTime = endTime - startTime;
     let queryResults;
     try {
-      queryResults = await runnable.run({ rowLimit });
+      queryResults = await runnable.run({ rowLimit, givens });
     } catch (error) {
       const errorEndTime = performance.now();
       const errorExecutionTime = errorEndTime - startTime;
@@ -231072,7 +231753,9 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
     };
   }
   getStandardModel() {
-    return {
+    if (this.cachedStandardModel)
+      return this.cachedStandardModel;
+    const compiled = {
       type: "source",
       packageName: this.packageName,
       modelPath: this.modelPath,
@@ -231082,8 +231765,11 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       modelInfo: JSON.stringify(this.modelDef ? modelDefToModelInfo(this.modelDef) : {}),
       sourceInfos: this.getSourceInfos()?.map((sourceInfo) => JSON.stringify(sourceInfo)),
       sources: this.sources,
-      queries: this.queries
+      queries: this.queries,
+      givens: this.givens
     };
+    this.cachedStandardModel = compiled;
+    return compiled;
   }
   async getNotebookModel() {
     const notebookCells = this.runnableNotebookCells.map((cell) => {
@@ -231117,7 +231803,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       notebookCells
     };
   }
-  async executeNotebookCell(cellIndex, filterParams, bypassFilters) {
+  async executeNotebookCell(cellIndex, filterParams, bypassFilters, givens) {
     if (this.compilationError) {
       throw this.compilationError;
     }
@@ -231152,8 +231838,8 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
             }
           }
         }
-        const rowLimit = (await runnableToExecute.getPreparedResult()).resultExplore.limit || ROW_LIMIT;
-        const result = await runnableToExecute.run({ rowLimit });
+        const rowLimit = (await runnableToExecute.getPreparedResult({ givens })).resultExplore.limit || ROW_LIMIT;
+        const result = await runnableToExecute.run({ rowLimit, givens });
         const query = (await runnableToExecute.getPreparedQuery())._query;
         queryName = query.as || query.name;
         queryResult = result?._queryResult && this.modelInfo && JSON.stringify(API.util.wrapResult(result));
@@ -231230,7 +231916,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       annotations: queryObj?.annotation?.blockNotes?.filter((note) => note.at.url.includes(modelPath)).map((note) => note.text)
     }));
   }
-  static getSources(modelPath, modelDef) {
+  static getSources(modelPath, modelDef, givens) {
     const filterMap = new Map;
     const sources = Object.values(modelDef.contents).filter((obj) => isSourceDef(obj)).map((sourceObj) => {
       const sourceName = sourceObj.as || sourceObj.name;
@@ -231275,7 +231961,8 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
         name: sourceName,
         annotations,
         views,
-        filters
+        filters,
+        givens
       };
     });
     return { sources, filterMap };
@@ -231707,6 +232394,8 @@ class Package {
 }
 
 // src/service/environment.ts
+var STAGING_DIR_NAME = ".staging";
+var RETIRED_DIR_NAME = ".retired";
 var RETIRED_CONNECTION_DRAIN_MS = 30000;
 
 class Environment {
@@ -231720,7 +232409,9 @@ class Environment {
   environmentPath;
   environmentName;
   metadata;
+  memoryGovernor = null;
   constructor(environmentName, environmentPath, malloyConfig, apiConnections) {
+    assertSafeEnvironmentPath(environmentPath);
     this.environmentName = environmentName;
     this.environmentPath = environmentPath;
     this.malloyConfig = malloyConfig;
@@ -231777,6 +232468,7 @@ class Environment {
       apiConnections: malloyConfig.apiConnections
     });
     const environment = new Environment(environmentName, environmentPath, malloyConfig, malloyConfig.apiConnections);
+    await Environment.sweepStaleInstallDirs(environmentPath);
     return environment;
   }
   async reloadEnvironmentMetadata() {
@@ -231792,47 +232484,51 @@ class Environment {
     };
     return this.metadata;
   }
-  async compileSource(packageName, modelName, source, includeSql = false) {
-    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 = path9.join(this.environmentPath, packageName, modelName);
-    let modelContent = "";
-    try {
-      modelContent = await fs6.promises.readFile(modelPath, "utf8");
-    } catch {}
-    const fullSource = modelContent ? `${modelContent}
+  async compileSource(packageName, modelName, source, includeSql = false, givens) {
+    assertSafePackageName(packageName);
+    assertSafeRelativeModelPath(modelName);
+    return this.withPackageLock(packageName, async () => {
+      const modelPath = safeJoinUnderRoot(this.environmentPath, packageName, modelName);
+      const modelDir = path9.dirname(modelPath);
+      const virtualUri = `file://${path9.join(modelDir, "__compile_check.malloy")}`;
+      const virtualUrl = new URL(virtualUri);
+      let modelContent = "";
+      try {
+        modelContent = await fs6.promises.readFile(modelPath, "utf8");
+      } catch {}
+      const fullSource = modelContent ? `${modelContent}
 ${source}` : source;
-    const interceptingReader = {
-      readURL: async (url2) => {
-        if (url2.toString() === virtualUri) {
-          return fullSource;
+      const interceptingReader = {
+        readURL: async (url2) => {
+          if (url2.toString() === virtualUri) {
+            return fullSource;
+          }
+          return URL_READER.readURL(url2);
+        }
+      };
+      const pkg = await this._loadOrGetPackageLocked(packageName);
+      const runtime = new Runtime2({
+        urlReader: interceptingReader,
+        config: pkg.getMalloyConfig()
+      });
+      try {
+        const modelMaterializer = runtime.loadModel(virtualUrl);
+        const model = await modelMaterializer.getModel();
+        let sql;
+        if (includeSql) {
+          try {
+            const queryMaterializer = modelMaterializer.loadFinalQuery();
+            sql = await queryMaterializer.getSQL({ givens });
+          } catch {}
+        }
+        return { problems: model.problems, sql };
+      } catch (error) {
+        if (error instanceof MalloyError3) {
+          return { problems: error.problems };
         }
-        return URL_READER.readURL(url2);
+        throw error;
       }
-    };
-    const pkg = await this.getPackage(packageName);
-    const runtime = new Runtime2({
-      urlReader: interceptingReader,
-      config: pkg.getMalloyConfig()
     });
-    try {
-      const modelMaterializer = runtime.loadModel(virtualUrl);
-      const model = await modelMaterializer.getModel();
-      let sql;
-      if (includeSql) {
-        try {
-          const queryMaterializer = modelMaterializer.loadFinalQuery();
-          sql = await queryMaterializer.getSQL();
-        } catch {}
-      }
-      return { problems: model.problems, sql };
-    } catch (error) {
-      if (error instanceof MalloyError3) {
-        return { problems: error.problems };
-      }
-      throw error;
-    }
   }
   listApiConnections() {
     return this.apiConnections;
@@ -231916,85 +232612,190 @@ ${source}` : source;
     }
     return packageMutex;
   }
-  async getPackage(packageName, reload = false) {
+  async withPackageLock(packageName, fn) {
+    assertSafePackageName(packageName);
+    return this.getOrCreatePackageMutex(packageName).runExclusive(fn);
+  }
+  allocateStagingPath(packageName) {
+    return safeJoinUnderRoot(this.environmentPath, STAGING_DIR_NAME, `${packageName}-${crypto4.randomUUID()}`);
+  }
+  allocateRetiredPath(packageName) {
+    return safeJoinUnderRoot(this.environmentPath, RETIRED_DIR_NAME, `${packageName}-${crypto4.randomUUID()}`);
+  }
+  static async sweepStaleInstallDirs(environmentPath) {
+    assertSafeEnvironmentPath(environmentPath);
+    for (const dirName of [STAGING_DIR_NAME, RETIRED_DIR_NAME]) {
+      const dir = safeJoinUnderRoot(environmentPath, dirName);
+      if (dir.indexOf("..") !== -1)
+        continue;
+      if (path9.basename(dir) !== dirName)
+        continue;
+      try {
+        await fs6.promises.rm(dir, { recursive: true, force: true });
+      } catch (err) {
+        logger.warn(`Failed to sweep stale ${dirName} dir at ${dir}`, {
+          error: err
+        });
+      }
+    }
+  }
+  setMemoryGovernor(governor) {
+    this.memoryGovernor = governor;
+  }
+  assertCanAdmitNewPackage(packageName, reason, allowAdmission) {
+    if (allowAdmission)
+      return;
+    if (!this.memoryGovernor?.isBackpressured())
+      return;
+    throw new ServiceUnavailableError(`Publisher is under memory pressure and cannot ${reason} (package "${packageName}", environment "${this.environmentName}"). Retry after the server's memory usage drops below the configured low-water mark.`);
+  }
+  async getPackage(packageName, reload = false, options = {}) {
+    assertSafePackageName(packageName);
     const _package = this.packages.get(packageName);
     if (_package !== undefined && !reload) {
       return _package;
     }
-    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 !== undefined && !reload) {
-        logger.debug(`Package ${packageName} loaded by another request`);
-        return existingPackage;
-      }
+    this.assertCanAdmitNewPackage(packageName, reload ? "reload a package" : "load a package", options.allowAdmission === true);
+    return this.withPackageLock(packageName, () => this._loadOrGetPackageLocked(packageName, reload));
+  }
+  async _loadOrGetPackageLocked(packageName, reload = false) {
+    const existingPackage = this.packages.get(packageName);
+    if (existingPackage !== undefined && !reload) {
+      return existingPackage;
     }
-    return packageMutex.runExclusive(async () => {
-      const existingPackage = this.packages.get(packageName);
-      if (existingPackage !== undefined && !reload) {
-        return existingPackage;
-      }
-      this.setPackageStatus(packageName, "loading" /* LOADING */);
-      try {
-        logger.debug(`Loading package ${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());
-        }
-        this.packages.set(packageName, _package2);
-        this.setPackageStatus(packageName, "serving" /* SERVING */);
-        logger.debug(`Successfully loaded package ${packageName}`);
-        return _package2;
-      } catch (error) {
-        logger.error(`Failed to load package ${packageName}`, { error });
-        this.packages.delete(packageName);
-        this.packageStatuses.delete(packageName);
-        throw error;
+    this.setPackageStatus(packageName, "loading" /* LOADING */);
+    try {
+      logger.debug(`Loading package ${packageName}...`);
+      const packagePath = safeJoinUnderRoot(this.environmentPath, packageName);
+      const _package = await Package.create(this.environmentName, packageName, packagePath, () => this.malloyConfig.malloyConfig);
+      if (existingPackage !== undefined && reload) {
+        this.retireConnectionGeneration(`package ${packageName}`, () => existingPackage.getMalloyConfig().releaseConnections());
       }
-    });
+      this.packages.set(packageName, _package);
+      this.setPackageStatus(packageName, "serving" /* SERVING */);
+      logger.debug(`Successfully loaded package ${packageName}`);
+      return _package;
+    } catch (error) {
+      logger.error(`Failed to load package ${packageName}`, { error });
+      this.packages.delete(packageName);
+      this.packageStatuses.delete(packageName);
+      throw error;
+    }
   }
-  async addPackage(packageName) {
-    const packagePath = path9.join(this.environmentPath, packageName);
+  async addPackage(packageName, options = {}) {
+    assertSafePackageName(packageName);
+    const packagePath = safeJoinUnderRoot(this.environmentPath, packageName);
     if (!await fs6.promises.access(packagePath).then(() => true).catch(() => false) || !(await fs6.promises.stat(packagePath))?.isDirectory()) {
       throw new PackageNotFoundError(`Package ${packageName} not found`);
     }
+    this.assertCanAdmitNewPackage(packageName, "add a new package", options.allowAdmission === true);
     logger.info(`Adding package ${packageName} to environment ${this.environmentName}`, {
       packagePath,
       malloyConfig: this.malloyConfig.malloyConfig
     });
-    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;
-      }
+    return this.withPackageLock(packageName, () => this._addPackageLocked(packageName));
+  }
+  async _addPackageLocked(packageName) {
+    const packagePath = safeJoinUnderRoot(this.environmentPath, packageName);
+    const existingPackage = this.packages.get(packageName);
+    if (existingPackage !== undefined) {
+      return existingPackage;
     }
-    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 installPackage(packageName, downloader) {
+    assertSafePackageName(packageName);
+    const stagingPath = this.allocateStagingPath(packageName);
+    await fs6.promises.mkdir(path9.dirname(stagingPath), { recursive: true });
+    try {
+      await downloader(stagingPath);
+    } catch (err) {
+      await fs6.promises.rm(stagingPath, { recursive: true, force: true }).catch(() => {});
+      throw err;
+    }
+    return this.withPackageLock(packageName, async () => {
+      const canonicalPath = safeJoinUnderRoot(this.environmentPath, packageName);
+      let retiredPath;
+      const oldPackage = this.packages.get(packageName);
+      const oldExistsOnDisk = await fs6.promises.access(canonicalPath).then(() => true).catch(() => false);
+      if (oldExistsOnDisk) {
+        retiredPath = this.allocateRetiredPath(packageName);
+        await fs6.promises.mkdir(path9.dirname(retiredPath), {
+          recursive: true
+        });
+        await fs6.promises.rename(canonicalPath, retiredPath);
       }
-      this.setPackageStatus(packageName, "loading" /* LOADING */);
+      let newPackage;
       try {
-        this.packages.set(packageName, await Package.create(this.environmentName, packageName, packagePath, () => this.malloyConfig.malloyConfig));
-      } catch (error) {
-        logger.error("Error adding package", { error });
+        await fs6.promises.rename(stagingPath, canonicalPath);
+        this.setPackageStatus(packageName, "loading" /* LOADING */);
+        newPackage = await Package.create(this.environmentName, packageName, canonicalPath, () => this.malloyConfig.malloyConfig);
+      } catch (err) {
+        await fs6.promises.rm(canonicalPath, { recursive: true, force: true }).catch(() => {});
+        if (retiredPath) {
+          try {
+            await fs6.promises.rename(retiredPath, canonicalPath);
+          } catch (restoreErr) {
+            logger.error("Failed to restore retired package after install rollback", {
+              error: restoreErr,
+              retiredPath,
+              canonicalPath
+            });
+          }
+        }
+        await fs6.promises.rm(stagingPath, { recursive: true, force: true }).catch(() => {});
         this.deletePackageStatus(packageName);
-        throw error;
+        throw err;
       }
+      this.packages.set(packageName, newPackage);
       this.setPackageStatus(packageName, "serving" /* SERVING */);
-      return this.packages.get(packageName);
+      if (oldPackage) {
+        this.retireConnectionGeneration(`package ${packageName}`, () => oldPackage.getMalloyConfig().releaseConnections());
+      }
+      if (retiredPath) {
+        const pathToClean = retiredPath;
+        setImmediate(() => {
+          fs6.promises.rm(pathToClean, { recursive: true, force: true }).catch((err) => {
+            logger.warn(`Failed to clean up retired package directory ${pathToClean}`, { error: err });
+          });
+        });
+      }
+      return newPackage;
+    });
+  }
+  async reloadAllModelsForPackage(packageName, manifest) {
+    assertSafePackageName(packageName);
+    return this.withPackageLock(packageName, async () => {
+      const pkg = this.packages.get(packageName);
+      if (!pkg) {
+        throw new PackageNotFoundError(`Package ${packageName} is not loaded`);
+      }
+      await pkg.reloadAllModels(manifest);
+    });
+  }
+  async getModelFileText(packageName, modelPath) {
+    assertSafePackageName(packageName);
+    assertSafeRelativeModelPath(modelPath);
+    return this.withPackageLock(packageName, async () => {
+      const pkg = this.packages.get(packageName);
+      if (!pkg) {
+        throw new PackageNotFoundError(`Package ${packageName} is not loaded`);
+      }
+      return pkg.getModelFileText(modelPath);
     });
   }
   async writePackageManifest(packageName, metadata) {
-    const packagePath = path9.join(this.environmentPath, packageName);
-    const manifestPath = path9.join(packagePath, "publisher.json");
+    const packagePath = safeJoinUnderRoot(this.environmentPath, packageName);
+    const manifestPath = safeJoinUnderRoot(packagePath, "publisher.json");
     try {
       let existingManifest = {};
       try {
@@ -232016,24 +232817,27 @@ ${source}` : source;
     }
   }
   async updatePackage(packageName, body) {
-    const _package = this.packages.get(packageName);
-    if (!_package) {
-      throw new PackageNotFoundError(`Package ${packageName} not found`);
-    }
-    if (body.name) {
-      _package.setName(body.name);
-    }
-    _package.setPackageMetadata({
-      name: body.name,
-      description: body.description,
-      resource: body.resource,
-      location: body.location
-    });
-    await this.writePackageManifest(packageName, {
-      name: packageName,
-      description: body.description
+    assertSafePackageName(packageName);
+    return this.withPackageLock(packageName, async () => {
+      const _package = this.packages.get(packageName);
+      if (!_package) {
+        throw new PackageNotFoundError(`Package ${packageName} not found`);
+      }
+      if (body.name) {
+        _package.setName(body.name);
+      }
+      _package.setPackageMetadata({
+        name: body.name,
+        description: body.description,
+        resource: body.resource,
+        location: body.location
+      });
+      await this.writePackageManifest(packageName, {
+        name: packageName,
+        description: body.description
+      });
+      return _package.getPackageMetadata();
     });
-    return _package.getPackageMetadata();
   }
   getPackageStatus(packageName) {
     return this.packageStatuses.get(packageName);
@@ -232050,35 +232854,49 @@ ${source}` : source;
     this.packageStatuses.delete(packageName);
   }
   async deletePackage(packageName) {
-    const _package = this.packages.get(packageName);
-    if (!_package) {
-      return;
-    }
-    const packageStatus = this.packageStatuses.get(packageName);
-    if (packageStatus?.status === "loading" /* LOADING */) {
-      logger.error("Package loading. Can't unload.", {
-        environmentName: this.environmentName,
-        packageName
-      });
-      throw new Error("Package loading. Can't unload. " + this.environmentName + " " + packageName);
-    } else if (packageStatus?.status === "serving" /* SERVING */) {
-      this.setPackageStatus(packageName, "unloading" /* UNLOADING */);
-    }
-    await _package.getMalloyConfig().releaseConnections();
-    try {
-      await fs6.promises.rm(path9.join(this.environmentPath, packageName), {
-        recursive: true,
-        force: true
-      });
-    } catch (err) {
-      logger.error("Error removing package directory while unloading package", {
-        error: err,
-        environmentName: this.environmentName,
-        packageName
-      });
-    }
-    this.packages.delete(packageName);
-    this.packageStatuses.delete(packageName);
+    assertSafePackageName(packageName);
+    return this.withPackageLock(packageName, async () => {
+      const _package = this.packages.get(packageName);
+      if (!_package) {
+        return;
+      }
+      const packageStatus = this.packageStatuses.get(packageName);
+      if (packageStatus?.status === "loading" /* LOADING */) {
+        logger.error("Package loading. Can't unload.", {
+          environmentName: this.environmentName,
+          packageName
+        });
+        throw new Error("Package loading. Can't unload. " + this.environmentName + " " + packageName);
+      } else if (packageStatus?.status === "serving" /* SERVING */) {
+        this.setPackageStatus(packageName, "unloading" /* UNLOADING */);
+      }
+      this.retireConnectionGeneration(`package ${packageName}`, () => _package.getMalloyConfig().releaseConnections());
+      const canonicalPath = safeJoinUnderRoot(this.environmentPath, packageName);
+      const retiredPath = this.allocateRetiredPath(packageName);
+      let renamed = false;
+      try {
+        await fs6.promises.mkdir(path9.dirname(retiredPath), {
+          recursive: true
+        });
+        await fs6.promises.rename(canonicalPath, retiredPath);
+        renamed = true;
+      } catch (err) {
+        logger.error("Error renaming package directory to retired during unload", {
+          error: err,
+          environmentName: this.environmentName,
+          packageName
+        });
+      }
+      this.packages.delete(packageName);
+      this.packageStatuses.delete(packageName);
+      if (renamed) {
+        setImmediate(() => {
+          fs6.promises.rm(retiredPath, { recursive: true, force: true }).catch((err) => {
+            logger.warn(`Failed to clean up retired package directory ${retiredPath}`, { error: err });
+          });
+        });
+      }
+    });
   }
   updateConnections(malloyConfig, _apiConnections, afterPreviousRelease) {
     const previousMalloyConfig = this.malloyConfig;
@@ -232199,12 +233017,12 @@ class EnvironmentStore {
   publisherConfigIsFrozen;
   finishedInitialization;
   isInitialized = false;
-  failedEnvironments = [];
   storageManager;
   s3Client = new import_client_s32.S3({
     followRegionRedirects: true
   });
   gcsClient;
+  memoryGovernor = null;
   constructor(serverRootPath) {
     this.serverRootPath = serverRootPath;
     this.gcsClient = new Storage;
@@ -232217,6 +233035,12 @@ class EnvironmentStore {
     this.storageManager = new StorageManager(storageConfig);
     this.finishedInitialization = this.initialize();
   }
+  setMemoryGovernor(governor) {
+    this.memoryGovernor = governor;
+    for (const env of this.environments.values()) {
+      env.setMemoryGovernor(governor);
+    }
+  }
   async addConfiguredEnvironment(environment) {
     try {
       await this.addEnvironment({
@@ -232232,10 +233056,6 @@ 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";
@@ -232281,6 +233101,7 @@ class EnvironmentStore {
                 resource: `${API_PREFIX}/connections/${conn.name}`,
                 ...conn.config
               })));
+              environmentInstance.setMemoryGovernor(this.memoryGovernor);
               const packages = await repository.listPackages(dbEnvironment.id);
               packages.forEach((pkg) => {
                 environmentInstance.setPackageStatus(pkg.name, "serving" /* SERVING */);
@@ -232298,11 +233119,7 @@ class EnvironmentStore {
         }
       }
       this.isInitialized = true;
-      if (this.failedEnvironments.length > 0) {
-        markDegraded();
-      } else {
-        markReady();
-      }
+      markReady();
       const initializationDuration = performance.now() - initialTime;
       logger.info(`Environment store successfully initialized in ${formatDuration(initializationDuration)}`);
     } catch (error) {
@@ -232538,12 +233355,7 @@ class EnvironmentStore {
       environments: [],
       initialized: this.isInitialized,
       frozenConfig: isPublisherConfigFrozen(this.serverRootPath),
-      operationalState: getOperationalState(),
-      ...this.failedEnvironments.length > 0 && {
-        failedEnvironments: [
-          ...this.failedEnvironments
-        ]
-      }
+      operationalState: getOperationalState()
     };
     const environments = await this.listEnvironments(true);
     await Promise.all(environments.map(async (environment) => {
@@ -232641,6 +233453,7 @@ class EnvironmentStore {
       absoluteEnvironmentPath = await this.scaffoldEnvironment(environment);
     }
     const newEnvironment = await Environment.create(environmentName, absoluteEnvironmentPath, environment.connections || []);
+    newEnvironment.setMemoryGovernor(this.memoryGovernor);
     if (!newEnvironment.metadata)
       newEnvironment.metadata = {};
     newEnvironment.metadata.location = absoluteEnvironmentPath;
@@ -232806,7 +233619,7 @@ class EnvironmentStore {
       });
     }
     for (const [groupedLocation, packagesForLocation] of locationGroups) {
-      const locationHash = crypto4.createHash("sha256").update(groupedLocation).digest("hex").substring(0, 16);
+      const locationHash = crypto5.createHash("sha256").update(groupedLocation).digest("hex").substring(0, 16);
       const tempDownloadPath = `${absoluteTargetPath}/.temp_${locationHash}`;
       await fs7.promises.mkdir(tempDownloadPath, { recursive: true });
       logger.info(`Created temporary directory: ${tempDownloadPath}`);
@@ -232995,9 +233808,9 @@ class EnvironmentStore {
       }
       const file = fs7.createWriteStream(zipFilePath);
       item.Body.transformToWebStream().pipeTo(Writable.toWeb(file));
-      await new Promise((resolve3, reject) => {
+      await new Promise((resolve4, reject) => {
         file.on("error", reject);
-        file.on("finish", resolve3);
+        file.on("finish", resolve4);
       });
       await this.unzipEnvironment(zipFilePath);
       logger.info(`Downloaded S3 zip file ${s3Path} to ${absoluteDirPath}`);
@@ -233035,9 +233848,9 @@ class EnvironmentStore {
       }
       const file = fs7.createWriteStream(absoluteFilePath);
       item.Body.transformToWebStream().pipeTo(Writable.toWeb(file));
-      await new Promise((resolve3, reject) => {
+      await new Promise((resolve4, reject) => {
         file.on("error", reject);
-        file.on("finish", resolve3);
+        file.on("finish", resolve4);
       });
     }));
     logger.info(`Downloaded S3 directory ${s3Path} to ${absoluteDirPath}`);
@@ -233070,14 +233883,14 @@ class EnvironmentStore {
     });
     await fs7.promises.mkdir(absoluteDirPath, { recursive: true });
     const repoUrl = `https://github.com/${owner}/${repoName}`;
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       esm_default2().clone(repoUrl, absoluteDirPath, {}, (err) => {
         if (err) {
           const errorData = this.extractErrorDataFromError(err);
           logger.error(`Failed to clone GitHub repository "${repoUrl}"`, errorData);
           reject(err);
         }
-        resolve3();
+        resolve4();
       });
     });
     if (!cleanPackagePath) {
@@ -233180,7 +233993,12 @@ class WatchModeController {
   };
 }
 
+// src/server.ts
+init_errors();
+init_logger();
+
 // src/service/resolve_environment.ts
+init_errors();
 async function resolveEnvironmentId(repository, environmentName) {
   const dbEnvironment = await repository.getEnvironmentByName(environmentName);
   if (!dbEnvironment) {
@@ -233212,6 +234030,8 @@ class ManifestController {
 }
 
 // src/controller/materialization.controller.ts
+init_errors();
+
 class MaterializationController {
   materializationService;
   constructor(materializationService) {
@@ -233473,7 +234293,7 @@ class Protocol {
   }
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken } = options !== null && options !== undefined ? options : {};
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       var _a2, _b, _c, _d, _e, _f;
       if (!this._transport) {
         reject(new Error("Not connected"));
@@ -233524,7 +234344,7 @@ class Protocol {
         }
         try {
           const result = resultSchema.parse(response.result);
-          resolve3(result);
+          resolve4(result);
         } catch (error) {
           reject(error);
         }
@@ -235898,6 +236718,12 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
+// src/mcp/server.ts
+init_logger();
+
+// src/mcp/prompts/prompt_service.ts
+init_logger();
+
 // src/mcp/prompts/handlers.ts
 var import_handlebars = __toESM(require_lib8(), 1);
 
@@ -236092,6 +236918,9 @@ function registerPromptCapability(mcpServer, environmentStore) {
   logger.info(`[MCP Init] Finished registering prompts. Registered: ${registeredCount}`, { duration: endTime - startTime });
 }
 
+// src/mcp/resources/environment_resource.ts
+init_logger();
+
 // src/mcp/error_messages.ts
 function getNotFoundError(resourceUriOrContext) {
   const baseMessage = `Resource not found: ${resourceUriOrContext}`;
@@ -236181,6 +237010,9 @@ function getMalloyErrorDetails(operation, modelIdentifier, error) {
 }
 
 // src/mcp/handler_utils.ts
+init_errors();
+init_logger();
+
 class McpGetResourceError extends Error {
   details;
   constructor(details) {
@@ -236393,6 +237225,7 @@ function registerEnvironmentResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/model_resource.ts
+init_errors();
 function registerModelResource(mcpServer, environmentStore) {
   mcpServer.resource("model", new ResourceTemplate("malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}", { list: undefined }), (uri, params) => handleResourceGet(uri, params, "model", async ({
     environmentName,
@@ -236452,6 +237285,8 @@ function registerModelResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/notebook_resource.ts
+init_errors();
+init_logger();
 function registerNotebookResource(mcpServer, environmentStore) {
   mcpServer.resource("notebook", new ResourceTemplate("malloy://environment/{environmentName}/package/{packageName}/notebooks/{notebookName}", { list: undefined }), (uri, params) => handleResourceGet(uri, params, "notebook", async ({ environmentName, packageName, notebookName }, uri2) => {
     if (typeof environmentName !== "string" || typeof packageName !== "string" || typeof notebookName !== "string") {
@@ -236491,6 +237326,8 @@ function registerNotebookResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/package_resource.ts
+init_errors();
+init_logger();
 async function handleGetPackageContents(uri, params, environmentStore) {
   try {
     const { environmentName, packageName } = params;
@@ -236683,6 +237520,8 @@ function registerPackageResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/query_resource.ts
+init_errors();
+init_logger();
 function registerQueryResource(mcpServer, environmentStore) {
   mcpServer.resource("query", new ResourceTemplate("malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}/queries/{queryName}", { list: undefined }), (uri, params) => handleResourceGet(uri, params, "query", async ({
     environmentName,
@@ -236725,6 +237564,8 @@ function registerQueryResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/source_resource.ts
+init_errors();
+init_logger();
 function registerSourceResource(mcpServer, environmentStore) {
   mcpServer.resource("source", new ResourceTemplate("malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}/sources/{sourceName}", { list: undefined }), (uri, params) => handleResourceGet(uri, params, "source", async ({
     environmentName,
@@ -236770,6 +237611,8 @@ function registerSourceResource(mcpServer, environmentStore) {
 }
 
 // src/mcp/resources/view_resource.ts
+init_errors();
+init_logger();
 function registerViewResource(mcpServer, environmentStore) {
   mcpServer.resource("view", new ResourceTemplate("malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}/sources/{sourceName}/views/{viewName}", { list: undefined }), (uri, params) => handleResourceGet(uri, params, "view", async ({
     environmentName,
@@ -236926,7 +237769,7 @@ function registerTools(mcpServer, environmentStore) {
         console.log("model not found", modelPath, "in ", pkg.listModels());
         throw new Error(`Model not found: ${modelPath}`);
       }
-      const fileText = await pkg.getModelFileText(modelPath);
+      const fileText = await environment.getModelFileText(packageName, modelPath);
       console.log(`[MCP LOG] Successfully retrieved model text for ${modelPath}`);
       return {
         content: [
@@ -236967,6 +237810,9 @@ function registerTools(mcpServer, environmentStore) {
   });
 }
 
+// src/mcp/tools/execute_query_tool.ts
+init_logger();
+
 // src/mcp/mcp_constants.ts
 var MCP_ERROR_MESSAGES = {
   MISSING_REQUIRED_PARAMS: "Either 'query' or both 'sourceName' and 'queryName' must be provided",
@@ -236989,7 +237835,8 @@ var executeQueryShape = {
   query: exports_external.string().optional().describe("Ad-hoc Malloy query code"),
   sourceName: exports_external.string().optional().describe("Source name for a view"),
   queryName: exports_external.string().optional().describe("Named query or view"),
-  filterParams: exports_external.record(exports_external.union([exports_external.string(), exports_external.array(exports_external.string())])).optional().describe("Filter parameter values keyed by filter name. Used with sources that declare #(filter) annotations.")
+  filterParams: exports_external.record(exports_external.union([exports_external.string(), exports_external.array(exports_external.string())])).optional().describe("Filter parameter values keyed by filter name. Used with sources that declare #(filter) annotations."),
+  givens: exports_external.record(exports_external.unknown()).optional().describe("Per-query given values that override model defaults. Keys are given names declared in the model's given: block.")
 };
 function registerExecuteQueryTool(mcpServer, environmentStore) {
   mcpServer.tool("malloy_executeQuery", "Executes a Malloy query (either ad-hoc or a named query/view defined in a model) against the specified model and returns the results as JSON.", executeQueryShape, async (params) => {
@@ -237000,7 +237847,8 @@ function registerExecuteQueryTool(mcpServer, environmentStore) {
       query,
       sourceName,
       queryName,
-      filterParams
+      filterParams,
+      givens
     } = params;
     logger.info("[MCP Tool executeQuery] Received params:", { params });
     const hasAdhocQuery = !!query;
@@ -237036,7 +237884,7 @@ function registerExecuteQueryTool(mcpServer, environmentStore) {
     logger.info(`[MCP Tool executeQuery] Model found. Proceeding to execute query.`);
     try {
       if (query) {
-        const { result } = await model.getQueryResults(undefined, undefined, query, filterParams);
+        const { result } = await model.getQueryResults(undefined, undefined, query, filterParams, undefined, givens);
         const { validateRenderTags: validateRenderTags2 } = await Promise.resolve().then(() => __toESM(require_dist10(), 1));
         const renderLogs = validateRenderTags2(result);
         const baseUriComponents = {
@@ -237072,7 +237920,7 @@ ${JSON.stringify(renderLogs, null, 2)}`
         }
         return { isError: false, content };
       } else if (queryName) {
-        const { result } = await model.getQueryResults(sourceName, queryName, undefined, filterParams);
+        const { result } = await model.getQueryResults(sourceName, queryName, undefined, filterParams, undefined, givens);
         const { validateRenderTags: validateRenderTags2 } = await Promise.resolve().then(() => __toESM(require_dist10(), 1));
         const renderLogs = validateRenderTags2(result);
         const baseUriComponents = {
@@ -237171,6 +238019,8 @@ function initializeMcpServer(environmentStore) {
 }
 
 // src/server-old.ts
+init_errors();
+init_logger();
 var import_body_parser = __toESM(require_body_parser(), 1);
 var LEGACY_API_PREFIX = "/api/v0";
 function remapMaterializationResponse(mat) {
@@ -237746,6 +238596,8 @@ function registerLegacyRoutes(app, controllers) {
 }
 
 // src/service/manifest_service.ts
+init_logger();
+
 class ManifestService {
   environmentStore;
   constructor(environmentStore) {
@@ -237766,8 +238618,8 @@ class ManifestService {
   async reloadManifest(environmentId, packageName, environmentName) {
     const manifest = await this.getManifest(environmentId, packageName);
     const environment = await this.environmentStore.getEnvironment(environmentName, false);
-    const pkg = await environment.getPackage(packageName, false);
-    await pkg.reloadAllModels(manifest.entries);
+    await environment.getPackage(packageName, false);
+    await environment.reloadAllModelsForPackage(packageName, manifest.entries);
     logger.info("Reloaded manifest and recompiled models", {
       environmentId,
       packageName,
@@ -237781,9 +238633,12 @@ class ManifestService {
 }
 
 // src/service/materialization_service.ts
+init_errors();
+init_logger();
 import { Manifest } from "@malloydata/malloy";
 
 // src/service/materialized_table_gc.ts
+init_logger();
 import {
   DatabricksDialect,
   DuckDBDialect,
@@ -238088,8 +238943,8 @@ class MaterializationService {
       if (metadata.autoLoadManifest) {
         const updatedManifest = await this.manifestService.getManifest(environmentId, packageName);
         const environment = await this.environmentStore.getEnvironment(environmentName, false);
-        const pkg = await environment.getPackage(packageName, false);
-        await pkg.reloadAllModels(updatedManifest.entries);
+        await environment.getPackage(packageName, false);
+        await environment.reloadAllModelsForPackage(packageName, updatedManifest.entries);
       }
       await this.transitionExecution(executionId, "SUCCESS", {
         completedAt: new Date,
@@ -238179,7 +239034,7 @@ class MaterializationService {
     manifest.loadText(JSON.stringify(existingManifest));
     const existingEntries = await this.manifestService.listEntries(environmentId, packageName);
     const knownMaterializedTables = new Set(existingEntries.map((e) => manifestTableKey(e.connectionName, e.tableName)));
-    const { graphs, sources, connectionDigests, connections } = await this.compilePackageBuildPlan(pkg, signal);
+    const { graphs, sources, connectionDigests, connections } = await environment.withPackageLock(packageName, () => this.compilePackageBuildPlan(pkg, signal));
     if (graphs.length === 0) {
       logger.info("No persist sources to build");
       return { sourcesBuilt: 0, sourcesSkipped: 0 };
@@ -238384,6 +239239,108 @@ class MaterializationService {
   }
 }
 
+// src/service/package_memory_governor.ts
+init_logger();
+var import_api4 = __toESM(require_src(), 1);
+var DEFAULT_RSS_SAMPLER = () => process.memoryUsage().rss;
+
+class PackageMemoryGovernor {
+  config;
+  rssSampler;
+  highWaterBytes;
+  lowWaterBytes;
+  timer = null;
+  backpressured = false;
+  lastSampledRss = 0;
+  lastSampledAt = null;
+  backpressureActivationsCounter;
+  constructor(config, rssSampler) {
+    this.config = config;
+    this.rssSampler = rssSampler ?? DEFAULT_RSS_SAMPLER;
+    this.highWaterBytes = Math.floor(config.maxMemoryBytes * config.highWaterFraction);
+    this.lowWaterBytes = Math.floor(config.maxMemoryBytes * config.lowWaterFraction);
+    const meter2 = import_api4.metrics.getMeter("publisher");
+    meter2.createObservableGauge("publisher_process_rss_bytes", {
+      description: "Current resident set size of the publisher process in bytes",
+      unit: "By"
+    }).addCallback((observation) => {
+      observation.observe(this.rssSampler());
+    });
+    meter2.createObservableGauge("publisher_memory_backpressure_active", {
+      description: "1 when the publisher is rejecting new package loads to stay under PUBLISHER_MAX_MEMORY_BYTES; 0 otherwise"
+    }).addCallback((observation) => {
+      observation.observe(this.backpressured ? 1 : 0);
+    });
+    this.backpressureActivationsCounter = meter2.createCounter("publisher_memory_backpressure_activations_total", {
+      description: "Number of times the memory governor has activated back-pressure"
+    });
+    meter2.createObservableGauge("publisher_memory_max_bytes", {
+      description: "Configured PUBLISHER_MAX_MEMORY_BYTES",
+      unit: "By"
+    }).addCallback((observation) => observation.observe(this.config.maxMemoryBytes));
+    meter2.createObservableGauge("publisher_memory_high_water_bytes", {
+      description: "RSS threshold at which back-pressure activates",
+      unit: "By"
+    }).addCallback((observation) => observation.observe(this.highWaterBytes));
+    meter2.createObservableGauge("publisher_memory_low_water_bytes", {
+      description: "RSS threshold at which back-pressure clears",
+      unit: "By"
+    }).addCallback((observation) => observation.observe(this.lowWaterBytes));
+  }
+  start() {
+    if (this.timer !== null)
+      return;
+    this.tick();
+    this.timer = setInterval(() => this.tick(), this.config.checkIntervalMs);
+    this.timer.unref?.();
+    logger.info(`PackageMemoryGovernor started (max=${this.config.maxMemoryBytes}B, high=${this.highWaterBytes}B, low=${this.lowWaterBytes}B, interval=${this.config.checkIntervalMs}ms, backpressure=${this.config.backpressureEnabled})`);
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.backpressured = false;
+  }
+  tick() {
+    let rss;
+    try {
+      rss = this.rssSampler();
+    } catch (err) {
+      logger.error("PackageMemoryGovernor: RSS sample failed", {
+        error: err
+      });
+      return;
+    }
+    this.lastSampledRss = rss;
+    this.lastSampledAt = Date.now();
+    if (!this.config.backpressureEnabled) {
+      return;
+    }
+    if (rss >= this.highWaterBytes && !this.backpressured) {
+      this.backpressured = true;
+      this.backpressureActivationsCounter.add(1);
+      logger.warn(`PackageMemoryGovernor: activating back-pressure (rss=${rss}B >= high=${this.highWaterBytes}B). New package loads will be rejected with HTTP 503 until rss <= ${this.lowWaterBytes}B.`);
+    } else if (rss <= this.lowWaterBytes && this.backpressured) {
+      this.backpressured = false;
+      logger.info(`PackageMemoryGovernor: clearing back-pressure (rss=${rss}B <= low=${this.lowWaterBytes}B).`);
+    }
+  }
+  isBackpressured() {
+    return this.backpressured;
+  }
+  getStatus() {
+    return {
+      rssBytes: this.lastSampledRss,
+      maxMemoryBytes: this.config.maxMemoryBytes,
+      highWaterBytes: this.highWaterBytes,
+      lowWaterBytes: this.lowWaterBytes,
+      backpressured: this.backpressured,
+      lastSampledAt: this.lastSampledAt
+    };
+  }
+}
+
 // src/server.ts
 function normalizeQueryArray(value) {
   if (value === undefined || value === null)
@@ -238452,7 +239409,7 @@ var MCP_PORT = Number(process.env.MCP_PORT || 4040);
 var MCP_ENDPOINT = "/mcp";
 var SHUTDOWN_DRAIN_DURATION_SECONDS = Number(process.env.SHUTDOWN_DRAIN_DURATION_SECONDS || 0);
 var SHUTDOWN_GRACEFUL_CLOSE_TIMEOUT_SECONDS = Number(process.env.SHUTDOWN_GRACEFUL_CLOSE_TIMEOUT_SECONDS || 0);
-var __filename_esm = fileURLToPath3(import.meta.url);
+var __filename_esm = fileURLToPath4(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";
@@ -238465,6 +239422,10 @@ var manifestService = new ManifestService(environmentStore);
 var watchModeController = new WatchModeController(environmentStore);
 var connectionController = new ConnectionController(environmentStore);
 var modelController = new ModelController(environmentStore);
+var memoryGovernorConfig = getMemoryGovernorConfig();
+var memoryGovernor = memoryGovernorConfig ? new PackageMemoryGovernor(memoryGovernorConfig) : null;
+memoryGovernor?.start();
+environmentStore.setMemoryGovernor(memoryGovernor);
 var packageController = new PackageController(environmentStore, manifestService);
 var databaseController = new DatabaseController(environmentStore);
 var queryController = new QueryController(environmentStore);
@@ -238983,7 +239944,18 @@ app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/note
       }
     }
     const bypassFilters = req.query.bypass_filters === "true" ? true : undefined;
-    res.status(200).json(await modelController.executeNotebookCell(req.params.environmentName, req.params.packageName, notebookPath, cellIndex, filterParams, bypassFilters));
+    let givens;
+    if (typeof req.query.givens === "string") {
+      try {
+        givens = JSON.parse(req.query.givens);
+      } catch {
+        res.status(400).json({
+          error: "Invalid givens: must be valid JSON"
+        });
+        return;
+      }
+    }
+    res.status(200).json(await modelController.executeNotebookCell(req.params.environmentName, req.params.packageName, notebookPath, cellIndex, filterParams, bypassFilters, givens));
   } catch (error) {
     logger.error(error);
     const { json, status } = internalErrorToHttpError(error);
@@ -239011,7 +239983,7 @@ app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/mod
   }
   try {
     const modelPath = req.params["0"];
-    res.status(200).json(await queryController.getQuery(req.params.environmentName, 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));
+    res.status(200).json(await queryController.getQuery(req.params.environmentName, 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, req.body.givens));
   } catch (error) {
     logger.error(error);
     const { json, status } = internalErrorToHttpError(error);
@@ -239033,7 +240005,7 @@ app.get(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/data
 });
 app.post(`${API_PREFIX2}/environments/:environmentName/packages/:packageName/models/:modelName/compile`, async (req, res) => {
   try {
-    const result = await compileController.compile(req.params.environmentName, req.params.packageName, req.params.modelName, req.body.source, req.body.includeSql === true);
+    const result = await compileController.compile(req.params.environmentName, req.params.packageName, req.params.modelName, req.body.source, req.body.includeSql === true, req.body.givens);
     res.status(200).json(result);
   } catch (error) {
     logger.error("Compilation error", { error });