@malloy-publisher/server 0.0.198-dev → 0.0.198-dev2

package/dist/server.mjs

@@ -196989,26 +196989,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 +197017,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 +197053,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 +197068,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 +197077,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 +197147,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 +197174,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 +197214,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 +198545,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 +199074,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 +199097,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;
@@ -199378,14 +199378,14 @@ var require_brace_expansion = __commonJS((exports, module) => {
 var require_minimatch = __commonJS((exports, module) => {
   module.exports = minimatch;
   minimatch.Minimatch = Minimatch;
-  var path6 = function() {
+  var path7 = function() {
     try {
       return __require("path");
     } catch (e) {}
   }() || {
     sep: "/"
   };
-  minimatch.sep = path6.sep;
+  minimatch.sep = path7.sep;
   var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
   var expand = require_brace_expansion();
   var plTypes = {
@@ -199476,8 +199476,8 @@ var require_minimatch = __commonJS((exports, module) => {
     if (!options)
       options = {};
     pattern = pattern.trim();
-    if (!options.allowWindowsEscape && path6.sep !== "/") {
-      pattern = pattern.split(path6.sep).join("/");
+    if (!options.allowWindowsEscape && path7.sep !== "/") {
+      pattern = pattern.split(path7.sep).join("/");
     }
     this.options = options;
     this.set = [];
@@ -199854,8 +199854,8 @@ var require_minimatch = __commonJS((exports, module) => {
     if (f === "/" && partial)
       return true;
     var options = this.options;
-    if (path6.sep !== "/") {
-      f = f.split(path6.sep).join("/");
+    if (path7.sep !== "/") {
+      f = f.split(path7.sep).join("/");
     }
     f = f.split(slashSplit);
     this.debug(this.pattern, "split", f);
@@ -199966,9 +199966,9 @@ var require_recursive_readdir = __commonJS((exports, module) => {
   var p = __require("path");
   var minimatch = require_minimatch();
   function patternMatcher(pattern) {
-    return function(path6, stats) {
+    return function(path7, stats) {
       var minimatcher = new minimatch.Minimatch(pattern, { matchBase: true });
-      return (!minimatcher.negate || stats.isFile()) && minimatcher.match(path6);
+      return (!minimatcher.negate || stats.isFile()) && minimatcher.match(path7);
     };
   }
   function toMatcherFunction(ignoreEntry) {
@@ -199978,25 +199978,25 @@ var require_recursive_readdir = __commonJS((exports, module) => {
       return patternMatcher(ignoreEntry);
     }
   }
-  function readdir3(path6, ignores, callback) {
+  function readdir3(path7, ignores, callback) {
     if (typeof ignores == "function") {
       callback = ignores;
       ignores = [];
     }
     if (!callback) {
-      return new Promise(function(resolve3, reject) {
-        readdir3(path6, ignores || [], function(err, data) {
+      return new Promise(function(resolve4, reject) {
+        readdir3(path7, ignores || [], function(err, data) {
           if (err) {
             reject(err);
           } else {
-            resolve3(data);
+            resolve4(data);
           }
         });
       });
     }
     ignores = ignores.map(toMatcherFunction);
     var list = [];
-    fs4.readdir(path6, function(err, files) {
+    fs4.readdir(path7, function(err, files) {
       if (err) {
         return callback(err);
       }
@@ -200005,7 +200005,7 @@ var require_recursive_readdir = __commonJS((exports, module) => {
         return callback(null, list);
       }
       files.forEach(function(file) {
-        var filePath = p.join(path6, file);
+        var filePath = p.join(path7, file);
         fs4.stat(filePath, function(_err, stats) {
           if (_err) {
             return callback(_err);
@@ -200771,7 +200771,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);
     }
@@ -200851,8 +200851,8 @@ var require_uri_all = __commonJS((exports, module) => {
           wsComponents.secure = undefined;
         }
         if (wsComponents.resourceName) {
-          var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path11 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
-          wsComponents.path = path11 && path11 !== "/" ? path11 : undefined;
+          var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path12 = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
+          wsComponents.path = path12 && path12 !== "/" ? path12 : undefined;
           wsComponents.query = query;
           wsComponents.resourceName = undefined;
         }
@@ -201039,7 +201039,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;
@@ -201245,12 +201245,12 @@ var require_util13 = __commonJS((exports, module) => {
     return "'" + escapeQuotes(str) + "'";
   }
   function getPathExpr(currentPath, expr, jsonPointers, isNumber2) {
-    var path11 = jsonPointers ? "'/' + " + expr + (isNumber2 ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber2 ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
-    return joinPaths(currentPath, path11);
+    var path12 = jsonPointers ? "'/' + " + expr + (isNumber2 ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber2 ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
+    return joinPaths(currentPath, path12);
   }
   function getPath(currentPath, prop, jsonPointers) {
-    var path11 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
-    return joinPaths(currentPath, path11);
+    var path12 = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty(prop));
+    return joinPaths(currentPath, path12);
   }
   var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
   var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
@@ -201405,20 +201405,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 +201641,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 +201656,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 +202199,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 +202259,7 @@ var require_compile2 = __commonJS((exports, module) => {
         RULES,
         validate: validateGenerator,
         util: util5,
-        resolve: resolve3,
+        resolve: resolve4,
         resolveRef,
         usePattern,
         useDefault,
@@ -202298,7 +202298,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 +202315,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 +205836,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 +205928,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 +205974,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 +205990,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 +206018,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 +206043,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,
@@ -207304,11 +207304,11 @@ var require_ast = __commonJS((exports, module) => {
       helperExpression: function helperExpression(node) {
         return node.type === "SubExpression" || (node.type === "MustacheStatement" || node.type === "BlockStatement") && !!(node.params && node.params.length || node.hash);
       },
-      scopedId: function scopedId(path11) {
-        return /^\.|this\b/.test(path11.original);
+      scopedId: function scopedId(path12) {
+        return /^\.|this\b/.test(path12.original);
       },
-      simpleId: function simpleId(path11) {
-        return path11.parts.length === 1 && !AST.helpers.scopedId(path11) && !path11.depth;
+      simpleId: function simpleId(path12) {
+        return path12.parts.length === 1 && !AST.helpers.scopedId(path12) && !path12.depth;
       }
     }
   };
@@ -208368,12 +208368,12 @@ var require_helpers3 = __commonJS((exports) => {
       loc
     };
   }
-  function prepareMustache(path11, params, hash, open2, strip, locInfo) {
+  function prepareMustache(path12, params, hash, open2, strip, locInfo) {
     var escapeFlag = open2.charAt(3) || open2.charAt(2), escaped = escapeFlag !== "{" && escapeFlag !== "&";
     var decorator = /\*/.test(open2);
     return {
       type: decorator ? "Decorator" : "MustacheStatement",
-      path: path11,
+      path: path12,
       params,
       hash,
       escaped,
@@ -208637,9 +208637,9 @@ var require_compiler = __commonJS((exports) => {
     },
     DecoratorBlock: function DecoratorBlock(decorator) {
       var program = decorator.program && this.compileProgram(decorator.program);
-      var params = this.setupFullMustacheParams(decorator, program, undefined), path11 = decorator.path;
+      var params = this.setupFullMustacheParams(decorator, program, undefined), path12 = decorator.path;
       this.useDecorators = true;
-      this.opcode("registerDecorator", params.length, path11.original);
+      this.opcode("registerDecorator", params.length, path12.original);
     },
     PartialStatement: function PartialStatement(partial) {
       this.usePartial = true;
@@ -208702,46 +208702,46 @@ var require_compiler = __commonJS((exports) => {
       }
     },
     ambiguousSexpr: function ambiguousSexpr(sexpr, program, inverse) {
-      var path11 = sexpr.path, name = path11.parts[0], isBlock = program != null || inverse != null;
-      this.opcode("getContext", path11.depth);
+      var path12 = sexpr.path, name = path12.parts[0], isBlock = program != null || inverse != null;
+      this.opcode("getContext", path12.depth);
       this.opcode("pushProgram", program);
       this.opcode("pushProgram", inverse);
-      path11.strict = true;
-      this.accept(path11);
+      path12.strict = true;
+      this.accept(path12);
       this.opcode("invokeAmbiguous", name, isBlock);
     },
     simpleSexpr: function simpleSexpr(sexpr) {
-      var path11 = sexpr.path;
-      path11.strict = true;
-      this.accept(path11);
+      var path12 = sexpr.path;
+      path12.strict = true;
+      this.accept(path12);
       this.opcode("resolvePossibleLambda");
     },
     helperSexpr: function helperSexpr(sexpr, program, inverse) {
-      var params = this.setupFullMustacheParams(sexpr, program, inverse), path11 = sexpr.path, name = path11.parts[0];
+      var params = this.setupFullMustacheParams(sexpr, program, inverse), path12 = sexpr.path, name = path12.parts[0];
       if (this.options.knownHelpers[name]) {
         this.opcode("invokeKnownHelper", params.length, name);
       } else if (this.options.knownHelpersOnly) {
         throw new _exception2["default"]("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
       } else {
-        path11.strict = true;
-        path11.falsy = true;
-        this.accept(path11);
-        this.opcode("invokeHelper", params.length, path11.original, _ast2["default"].helpers.simpleId(path11));
+        path12.strict = true;
+        path12.falsy = true;
+        this.accept(path12);
+        this.opcode("invokeHelper", params.length, path12.original, _ast2["default"].helpers.simpleId(path12));
       }
     },
-    PathExpression: function PathExpression(path11) {
-      this.addDepth(path11.depth);
-      this.opcode("getContext", path11.depth);
-      var name = path11.parts[0], scoped = _ast2["default"].helpers.scopedId(path11), blockParamId = !path11.depth && !scoped && this.blockParamIndex(name);
+    PathExpression: function PathExpression(path12) {
+      this.addDepth(path12.depth);
+      this.opcode("getContext", path12.depth);
+      var name = path12.parts[0], scoped = _ast2["default"].helpers.scopedId(path12), blockParamId = !path12.depth && !scoped && this.blockParamIndex(name);
       if (blockParamId) {
-        this.opcode("lookupBlockParam", blockParamId, path11.parts);
+        this.opcode("lookupBlockParam", blockParamId, path12.parts);
       } else if (!name) {
         this.opcode("pushContext");
-      } else if (path11.data) {
+      } else if (path12.data) {
         this.options.data = true;
-        this.opcode("lookupData", path11.depth, path11.parts, path11.strict);
+        this.opcode("lookupData", path12.depth, path12.parts, path12.strict);
       } else {
-        this.opcode("lookupOnContext", path11.parts, path11.falsy, path11.strict, scoped);
+        this.opcode("lookupOnContext", path12.parts, path12.falsy, path12.strict, scoped);
       }
     },
     StringLiteral: function StringLiteral(string2) {
@@ -209085,16 +209085,16 @@ var require_util14 = __commonJS((exports) => {
   }
   exports.urlGenerate = urlGenerate;
   function normalize2(aPath) {
-    var path11 = aPath;
+    var path12 = aPath;
     var url2 = urlParse(aPath);
     if (url2) {
       if (!url2.path) {
         return aPath;
       }
-      path11 = url2.path;
+      path12 = url2.path;
     }
-    var isAbsolute3 = exports.isAbsolute(path11);
-    var parts = path11.split(/\/+/);
+    var isAbsolute4 = exports.isAbsolute(path12);
+    var parts = path12.split(/\/+/);
     for (var part, up = 0, i = parts.length - 1;i >= 0; i--) {
       part = parts[i];
       if (part === ".") {
@@ -209111,18 +209111,18 @@ var require_util14 = __commonJS((exports) => {
         }
       }
     }
-    path11 = parts.join("/");
-    if (path11 === "") {
-      path11 = isAbsolute3 ? "/" : ".";
+    path12 = parts.join("/");
+    if (path12 === "") {
+      path12 = isAbsolute4 ? "/" : ".";
     }
     if (url2) {
-      url2.path = path11;
+      url2.path = path12;
       return urlGenerate(url2);
     }
-    return path11;
+    return path12;
   }
   exports.normalize = normalize2;
-  function join9(aRoot, aPath) {
+  function join8(aRoot, aPath) {
     if (aRoot === "") {
       aRoot = ".";
     }
@@ -209154,7 +209154,7 @@ var require_util14 = __commonJS((exports) => {
     }
     return joined;
   }
-  exports.join = join9;
+  exports.join = join8;
   exports.isAbsolute = function(aPath) {
     return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
   };
@@ -209327,7 +209327,7 @@ var require_util14 = __commonJS((exports) => {
           parsed.path = parsed.path.substring(0, index + 1);
         }
       }
-      sourceURL = join9(urlGenerate(parsed), sourceURL);
+      sourceURL = join8(urlGenerate(parsed), sourceURL);
     }
     return normalize2(sourceURL);
   }
@@ -211676,8 +211676,8 @@ var require_printer = __commonJS((exports) => {
     return this.accept(sexpr.path) + " " + params + hash;
   };
   PrintVisitor.prototype.PathExpression = function(id) {
-    var path11 = id.parts.join("/");
-    return (id.data ? "@" : "") + "PATH:" + path11;
+    var path12 = id.parts.join("/");
+    return (id.data ? "@" : "") + "PATH:" + path12;
   };
   PrintVisitor.prototype.StringLiteral = function(string2) {
     return '"' + string2.value + '"';
@@ -211736,6 +211736,7 @@ 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);
+import { monitorEventLoopDelay } from "node:perf_hooks";
 
 // src/logger.ts
 var import_winston = __toESM(require_winston(), 1);
@@ -211754,9 +211755,7 @@ var getLogLevel = () => {
 };
 var logger = import_winston.default.createLogger({
   level: getLogLevel(),
-  format: isTelemetryEnabled ? import_winston.default.format.combine(import_winston.default.format.uncolorize(), import_winston.default.format.timestamp(), import_winston.default.format.metadata({
-    fillExcept: ["message", "level", "timestamp"]
-  }), import_winston.default.format.json()) : import_winston.default.format.combine(import_winston.default.format.colorize(), import_winston.default.format.simple()),
+  format: isTelemetryEnabled ? import_winston.default.format.combine(import_winston.default.format.uncolorize(), import_winston.default.format.timestamp(), import_winston.default.format.errors({ stack: true }), import_winston.default.format.json()) : import_winston.default.format.combine(import_winston.default.format.colorize(), import_winston.default.format.simple()),
   transports: [new import_winston.default.transports.Console]
 });
 function extractTraceIdFromTraceparent(traceparent) {
@@ -211906,6 +211905,26 @@ var httpRequestDuration = meter.createHistogram("http_server_request_duration_ms
 var httpRequestCount = meter.createCounter("http_server_requests_total", {
   description: "Total number of HTTP requests"
 });
+var eventLoopHistogram = monitorEventLoopDelay({ resolution: 20 });
+eventLoopHistogram.enable();
+var eventLoopLagP50 = meter.createObservableGauge("publisher_event_loop_lag_p50_ms", {
+  description: "Event loop delay p50 since the last scrape, in milliseconds",
+  unit: "ms"
+});
+var eventLoopLagP99 = meter.createObservableGauge("publisher_event_loop_lag_p99_ms", {
+  description: "Event loop delay p99 since the last scrape, in milliseconds",
+  unit: "ms"
+});
+var eventLoopLagMax = meter.createObservableGauge("publisher_event_loop_lag_max_ms", {
+  description: "Event loop delay max since the last scrape, in milliseconds",
+  unit: "ms"
+});
+meter.addBatchObservableCallback((observableResult) => {
+  observableResult.observe(eventLoopLagP50, eventLoopHistogram.percentile(50) / 1e6);
+  observableResult.observe(eventLoopLagP99, eventLoopHistogram.percentile(99) / 1e6);
+  observableResult.observe(eventLoopLagMax, eventLoopHistogram.max / 1e6);
+  eventLoopHistogram.reset();
+}, [eventLoopLagP50, eventLoopLagP99, eventLoopLagMax]);
 var IGNORED_PATHS = new Set([
   "/health",
   "/health/liveness",
@@ -216946,8 +216965,8 @@ var import_cors = __toESM(require_lib7(), 1);
 var import_express = __toESM(require_express(), 1);
 var import_http_proxy_middleware = __toESM(require_dist4(), 1);
 import * as http2 from "http";
-import * as path11 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import * as path12 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/controller/compile.controller.ts
 class CompileController {
@@ -216955,9 +216974,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",
@@ -216998,6 +217017,8 @@ function internalErrorToHttpError(error) {
     return httpError(400, error.message);
   } else if (error instanceof ConnectionNotFoundError) {
     return httpError(404, error.message);
+  } else if (error instanceof ConnectionAuthError) {
+    return httpError(422, error.message);
   } else if (error instanceof ModelCompilationError) {
     return httpError(424, error.message);
   } else if (error instanceof ConnectionError) {
@@ -217008,6 +217029,8 @@ function internalErrorToHttpError(error) {
     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);
   }
@@ -217064,6 +217087,12 @@ class ConnectionError extends Error {
   }
 }
 
+class ConnectionAuthError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+
 class ModelCompilationError extends Error {
   constructor(error) {
     super(error.message);
@@ -217094,6 +217123,12 @@ class InvalidStateTransitionError extends Error {
   }
 }
 
+class ServiceUnavailableError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+
 // src/service/connection.ts
 import"@malloydata/db-bigquery";
 import"@malloydata/db-databricks";
@@ -220380,6 +220415,63 @@ var {
 import fs from "fs/promises";
 import path2 from "path";
 
+// src/pg_helpers.ts
+function pgConnectTimeoutSeconds() {
+  const raw = process.env.PG_CONNECT_TIMEOUT_SECONDS;
+  if (!raw)
+    return 5;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 5;
+}
+var URI_FORM_RE = /^[a-z][a-z0-9+.-]*:\/\//i;
+var HAS_CONNECT_TIMEOUT_RE = /[?&\s]connect_timeout=|^connect_timeout=/;
+function withPgConnectTimeout(connectionString, timeout) {
+  if (HAS_CONNECT_TIMEOUT_RE.test(connectionString)) {
+    return connectionString;
+  }
+  if (URI_FORM_RE.test(connectionString)) {
+    if (!connectionString.includes("?")) {
+      return `${connectionString}?connect_timeout=${timeout}`;
+    }
+    if (connectionString.endsWith("?")) {
+      return `${connectionString}connect_timeout=${timeout}`;
+    }
+    return `${connectionString}&connect_timeout=${timeout}`;
+  }
+  return `${connectionString} connect_timeout=${timeout}`;
+}
+function redactPgSecrets(s) {
+  return s.replace(/password=('[^']*'|"[^"]*"|\S+)/gi, "password=***");
+}
+function classifyPgError(error, context) {
+  if (!(error instanceof Error))
+    return;
+  const msg = error.message;
+  const patterns = [
+    /password authentication failed/i,
+    /pg_hba\.conf/i,
+    /role ".*" does not exist/i,
+    /database ".*" does not exist/i,
+    /permission denied/i
+  ];
+  if (!patterns.some((p) => p.test(msg)))
+    return;
+  return new ConnectionAuthError(`${context}: ${redactPgSecrets(msg)}`);
+}
+function handlePgAttachError(error, context) {
+  if (error instanceof Error && (error.message.includes("already exists") || error.message.includes("already attached"))) {
+    return { action: "swallow" };
+  }
+  const authErr = classifyPgError(error, context);
+  if (authErr) {
+    return { action: "throw", error: authErr };
+  }
+  if (error instanceof Error) {
+    return { action: "throw", error };
+  }
+  return { action: "throw", error: new Error(String(error)) };
+}
+
 // src/service/connection_config.ts
 import { createPrivateKey } from "crypto";
 import path from "path";
@@ -220563,7 +220655,7 @@ function validateConnectionShape(connection) {
       {
         const attached = connection.duckdbConnection.attachedDatabases ?? [];
         if (attached.length === 0) {
-          throw new Error("DuckDB connection must have at least one attached database");
+          throw new Error(`DuckDB connection "${connection.name}" has no attached databases. Add at least one foreign database (BigQuery, Snowflake, Postgres, GCS, S3, Azure) to attachedDatabases, or remove this connection entirely — each package already gets a per-package DuckDB sandbox named "duckdb" automatically.`);
         }
       }
       break;
@@ -220636,7 +220728,7 @@ function assembleEnvironmentConnections(connections = [], environmentPath = "")
       continue;
     }
     if (connection.name === "duckdb") {
-      throw new Error("DuckDB connection name cannot be 'duckdb'; it is reserved for Publisher package sandboxes.");
+      throw new Error("Connection name 'duckdb' is reserved for per-package sandboxes. Choose a different name for environment-level DuckDB connections (e.g. 'shared_duckdb').");
     }
     processedConnections.add(connection.name);
     validateDuckdbApiSurface(connection);
@@ -221005,13 +221097,13 @@ async function attachDuckLake(connection, dbName, ducklakeConfig) {
   }
   const pg = ducklakeConfig.catalog.postgresConnection;
   const pgConnString = buildPgConnectionString(pg);
-  logger.info(`pgConnString: ${pgConnString}`);
+  logger.info(`pgConnString: ${redactPgSecrets(pgConnString)}`);
   const escapedPgConnString = escapeSQL(pgConnString);
-  logger.info(`Final escaped connection string: ${escapedPgConnString}`);
+  logger.info(`Final escaped connection string: ${redactPgSecrets(escapedPgConnString)}`);
   const escapedBucketUrl = escapeSQL(ducklakeConfig.storage.bucketUrl);
   logger.info(`escapedBucketUrl: ${escapedBucketUrl}`);
   const attachCommand = `ATTACH OR REPLACE 'ducklake:postgres:${escapedPgConnString}' AS ${dbName} (DATA_PATH '${escapedBucketUrl}', OVERRIDE_DATA_PATH true, READ_ONLY true);`;
-  logger.info(`Attaching DuckLake database using command: ${attachCommand}`);
+  logger.info(`Attaching DuckLake database using command: ${redactPgSecrets(attachCommand)}`);
   try {
     await connection.runSQL(attachCommand);
     logger.info(`Successfully attached DuckLake database in READ_ONLY mode: ${dbName}`);
@@ -222783,7 +222875,7 @@ function validateAzureAttachedDatabases(connectionConfig) {
 }
 function validateAdminAuthoredConnection(connectionName, connectionConfig) {
   if (connectionName === "duckdb" || connectionConfig.name === "duckdb") {
-    throw new BadRequestError("DuckDB connection name cannot be 'duckdb'; it is reserved for Publisher package sandboxes.");
+    throw new BadRequestError("Connection name 'duckdb' is reserved for per-package sandboxes. Choose a different name for environment-level DuckDB connections (e.g. 'shared_duckdb').");
   }
   try {
     validateDuckdbApiSurface(connectionConfig);
@@ -223083,7 +223175,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);
@@ -223093,12 +223185,11 @@ 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";
 class PackageController {
   environmentStore;
   manifestService;
@@ -223112,11 +223203,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) {
@@ -223126,14 +223226,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;
   }
@@ -223175,24 +223279,24 @@ 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);
     }
   }
 }
@@ -223211,14 +223315,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),
@@ -223306,7 +223410,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;
     }
@@ -223331,8 +223435,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)
@@ -223372,20 +223476,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) {
@@ -223784,16 +223888,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) {
@@ -223809,12 +223913,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);
@@ -223824,7 +223928,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) => {
@@ -223833,7 +223937,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) {}
@@ -223863,7 +223967,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;
@@ -223885,7 +223989,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));
         }
       })
     };
@@ -223908,13 +224012,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
     };
@@ -223924,12 +224028,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
@@ -223947,7 +224051,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) {
@@ -223961,11 +224065,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;
           }
@@ -223989,7 +224093,7 @@ class NodeFsHandler {
     }
     return closer;
   }
-  async _handleSymlink(entry, directory, path4, item) {
+  async _handleSymlink(entry, directory, path3, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -223999,7 +224103,7 @@ class NodeFsHandler {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path4);
+        linkPath = await fsrealpath(path3);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -224009,12 +224113,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;
@@ -224043,9 +224147,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) {
@@ -224054,8 +224158,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) => {
@@ -224104,13 +224208,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);
@@ -224126,8 +224230,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);
@@ -224137,29 +224241,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;
       }
     }
   }
@@ -224203,26 +224307,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;
     }
   }
@@ -224262,19 +224366,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);
 
@@ -224331,10 +224435,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 = [];
@@ -224447,20 +224551,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;
@@ -224479,17 +224583,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
         });
       }
@@ -224538,38 +224642,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) {
@@ -224587,16 +224691,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);
@@ -224615,23 +224719,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);
@@ -224639,50 +224743,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;
         }
@@ -224690,8 +224794,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;
@@ -224701,13 +224805,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);
@@ -224721,57 +224825,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);
   }
@@ -224801,7 +224905,7 @@ function watch(paths, options = {}) {
 var esm_default = { watch, FSWatcher };
 
 // src/controller/watch-mode.controller.ts
-import path10 from "path";
+import path11 from "path";
 
 // src/service/environment_store.ts
 var import_client_s32 = __toESM(require_dist_cjs75(), 1);
@@ -225017,9 +225121,9 @@ class Mutex {
 }
 
 // src/service/environment_store.ts
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 import * as fs7 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist11(), 1);
@@ -225057,8 +225161,8 @@ 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) || [];
@@ -225144,8 +225248,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)) {
@@ -225526,8 +225630,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path4) {
-      return /^\.(git)?$/.test(path4.trim());
+    parser(path3) {
+      return /^\.(git)?$/.test(path3.trim());
     }
   };
 }
@@ -225938,11 +226042,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
     });
   });
@@ -226604,14 +226708,14 @@ var init_hash_object = __esm({
     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(" ");
@@ -226622,7 +226726,7 @@ 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;
@@ -226630,9 +226734,9 @@ var reInitResponseRegex;
 var init_InitSummary = __esm({
   "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;
       }
@@ -226644,7 +226748,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);
@@ -226653,7 +226757,7 @@ 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);
     }
   };
 }
@@ -227368,12 +227472,12 @@ var init_FileStatusSummary = __esm({
   "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] || "";
         }
@@ -227404,14 +227508,14 @@ 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));
     }
   }
 }
@@ -227642,8 +227746,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));
@@ -228220,8 +228324,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]);
@@ -228489,8 +228593,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));
@@ -229006,7 +229110,93 @@ import { Writable } from "stream";
 
 // src/config.ts
 import fs2 from "fs";
-import path4 from "path";
+import path3 from "path";
+import { fileURLToPath } from "url";
+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) {
+    if (!fs2.existsSync(explicitPath)) {
+      return null;
+    }
+    return { path: explicitPath, isBundledDefault: false };
+  }
+  const serverRootPath = path3.join(serverRoot, PUBLISHER_CONFIG_NAME);
+  if (fs2.existsSync(serverRootPath)) {
+    return { path: serverRootPath, isBundledDefault: false };
+  }
+  if (process.env.PUBLISHER_USE_BUNDLED_DEFAULT === "true" && fs2.existsSync(BUNDLED_DEFAULT_CONFIG_PATH)) {
+    return { path: BUNDLED_DEFAULT_CONFIG_PATH, isBundledDefault: true };
+  }
+  return null;
+}
+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) => {
@@ -229034,13 +229224,20 @@ function processConfigValue(value) {
   return value;
 }
 var getPublisherConfig = (serverRoot) => {
-  const publisherConfigPath = path4.join(serverRoot, PUBLISHER_CONFIG_NAME);
-  if (!fs2.existsSync(publisherConfigPath)) {
+  const resolved = resolvePublisherConfigPath(serverRoot);
+  if (!resolved) {
+    if (process.env.PUBLISHER_CONFIG_PATH && process.env.PUBLISHER_CONFIG_PATH.length > 0) {
+      logger.error(`--config path not found: ${process.env.PUBLISHER_CONFIG_PATH}. Using default empty config.`);
+    }
     return {
       frozenConfig: false,
       environments: []
     };
   }
+  const publisherConfigPath = resolved.path;
+  if (resolved.isBundledDefault) {
+    logger.info(`No publisher.config.json found at ${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 {
     const fileContent = fs2.readFileSync(publisherConfigPath, "utf8");
@@ -229058,6 +229255,10 @@ var getPublisherConfig = (serverRoot) => {
     };
   }
   const processedConfig = processConfigValue(rawConfig);
+  if (processedConfig && typeof processedConfig === "object" && !("environments" in processedConfig) && "projects" in processedConfig) {
+    logger.warn(`${PUBLISHER_CONFIG_NAME} uses deprecated "projects" key; rename to "environments".`);
+    processedConfig.environments = processedConfig.projects;
+  }
   if (processedConfig && typeof processedConfig === "object" && "environments" in processedConfig && processedConfig.environments && typeof processedConfig.environments === "object" && !Array.isArray(processedConfig.environments)) {
     logger.error(`Invalid ${PUBLISHER_CONFIG_NAME}: the "environments" field must be a JSON array. Using default empty config.`);
     return {
@@ -229195,37 +229396,40 @@ 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) {}
+  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")) {
@@ -229264,7 +229468,7 @@ 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;
@@ -229272,7 +229476,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) => {
@@ -230075,6 +230279,7 @@ async function initializeSchema(db, force = false) {
     logger.info("Reinitializing database schema dropping and recreating all tables");
     await dropAllTables(db);
   } else {
+    await dropLegacyProjectSchema(db);
     logger.info("Creating database schema for the first time...");
   }
   await db.run(`
@@ -230152,6 +230357,27 @@ async function initializeSchema(db, force = false) {
   await db.run("CREATE UNIQUE INDEX IF NOT EXISTS idx_materializations_active_key ON materializations(active_key)");
   await db.run("CREATE INDEX IF NOT EXISTS idx_build_manifests_environment_package ON build_manifests(environment_id, package_name)");
 }
+var LEGACY_TABLES_DROP_ORDER = [
+  "build_manifests",
+  "materializations",
+  "packages",
+  "connections",
+  "projects"
+];
+async function dropLegacyProjectSchema(db) {
+  const legacy = await db.all("SELECT name FROM sqlite_master WHERE type='table' AND name='projects'");
+  if (!legacy || legacy.length === 0) {
+    return;
+  }
+  logger.warn("Detected legacy 'projects' schema. Dropping legacy tables; existing environments/packages/connections/materializations data will be lost. Re-create them via the API after upgrade.");
+  for (const table of LEGACY_TABLES_DROP_ORDER) {
+    try {
+      await db.run(`DROP TABLE IF EXISTS ${table}`);
+    } catch (err) {
+      logger.warn(`Failed to drop legacy table ${table}:`, err);
+    }
+  }
+}
 async function dropAllTables(db) {
   const tables = [
     "build_manifests",
@@ -230267,6 +230493,7 @@ class StorageManager {
   defaultManifestStore = null;
   environmentManifestStores = new Map;
   attachedCatalogs = new Map;
+  duckLakeAttachMutex = new Mutex;
   config;
   constructor(config) {
     this.config = config;
@@ -230304,12 +230531,15 @@ class StorageManager {
       throw new Error("Storage not initialized. Call initialize() first.");
     }
     const key = configKey(config);
-    let catalogName = this.attachedCatalogs.get(key);
-    if (!catalogName) {
-      catalogName = catalogNameForConfig(config);
-      await this.attachDuckLakeCatalog(config, catalogName);
-      this.attachedCatalogs.set(key, catalogName);
-    }
+    const catalogName = await this.duckLakeAttachMutex.runExclusive(async () => {
+      const existing = this.attachedCatalogs.get(key);
+      if (existing)
+        return existing;
+      const name = catalogNameForConfig(config);
+      await this.attachDuckLakeCatalog(config, name);
+      this.attachedCatalogs.set(key, name);
+      return name;
+    });
     const store = new DuckLakeManifestStore(this.duckDbConnection, catalogName, environmentName);
     await store.bootstrapSchema();
     this.environmentManifestStores.set(environmentId, store);
@@ -230326,9 +230556,13 @@ class StorageManager {
     if (isPostgres) {
       await connection.run("INSTALL postgres; LOAD postgres;");
     }
-    const escapedCatalogUrl = escapeSQL2(config.catalogUrl);
+    const catalogUrl = isPostgres ? withPgConnectTimeout(config.catalogUrl, pgConnectTimeoutSeconds()) : config.catalogUrl;
+    const escapedCatalogUrl = escapeSQL2(catalogUrl);
     const escapedDataPath = escapeSQL2(config.dataPath);
     const isCloudStorage = config.dataPath.startsWith("gs://") || config.dataPath.startsWith("s3://");
+    if (isCloudStorage) {
+      await connection.run("INSTALL httpfs; LOAD httpfs;");
+    }
     let attachCmd = `ATTACH 'ducklake:${escapedCatalogUrl}' AS ${catalogName}`;
     const attachOpts = [
       `DATA_PATH '${escapedDataPath}'`,
@@ -230338,8 +230572,22 @@ class StorageManager {
       attachOpts.push("OVERRIDE_DATA_PATH true");
     }
     attachCmd += ` (${attachOpts.join(", ")});`;
-    logger.info(`Attaching DuckLake manifest catalog: ${attachCmd}`);
-    await connection.run(attachCmd);
+    logger.info(`Attaching DuckLake manifest catalog: ${redactPgSecrets(attachCmd)}`);
+    try {
+      await connection.run(attachCmd);
+    } catch (error) {
+      const outcome = handlePgAttachError(error, `DuckLake catalog credentials rejected for ${catalogName}`);
+      if (outcome.action === "swallow") {
+        logger.info(`DuckLake catalog ${catalogName} is already attached, skipping`);
+        return;
+      }
+      if (outcome.error instanceof ConnectionAuthError) {
+        logger.warn("DuckLake catalog credentials rejected", {
+          catalogName
+        });
+      }
+      throw outcome.error;
+    }
   }
   getRepository() {
     if (!this.repository) {
@@ -230377,33 +230625,86 @@ class StorageManager {
 
 // src/service/environment.ts
 import { MalloyError as MalloyError3, Runtime as Runtime2 } from "@malloydata/malloy";
+import crypto4 from "crypto";
 import * as fs6 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
+
+// src/path_safety.ts
+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 { fileURLToPath } from "url";
+import * as path6 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var URL_READER = {
   readURL: (url2) => {
-    let path6 = url2.toString();
+    let path7 = url2.toString();
     if (url2.protocol == "file:") {
-      path6 = fileURLToPath(url2);
+      path7 = fileURLToPath2(url2);
     }
-    return fs3.promises.readFile(path6, "utf8");
+    return fs3.promises.readFile(path7, "utf8");
   }
 };
+function ignoreDotfiles(file) {
+  return path6.basename(file).startsWith(".");
+}
 
 // src/service/package.ts
 var import_api3 = __toESM(require_src(), 1);
 var import_recursive_readdir = __toESM(require_recursive_readdir(), 1);
 import * as fs5 from "fs/promises";
-import * as path7 from "path";
-import { DuckDBConnection as DuckDBConnection3 } from "@malloydata/db-duckdb";
-import"@malloydata/db-duckdb/native";
+import * as path8 from "path";
 import {
-  ConnectionRuntime,
   contextOverlay as contextOverlay2,
-  EmptyURLReader,
   FixedConnectionMap as FixedConnectionMap2,
   MalloyConfig as MalloyConfig3
 } from "@malloydata/malloy";
@@ -230425,7 +230726,7 @@ import {
 } from "@malloydata/malloy-sql";
 import * as fs4 from "fs/promises";
 import { createRequire as createRequire2 } from "module";
-import * as path6 from "path";
+import * as path7 from "path";
 
 // src/data_styles.ts
 function compileDataStyles(styles) {
@@ -230666,6 +230967,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;
@@ -230681,12 +230991,13 @@ class Model {
   runnableNotebookCells;
   compilationError;
   filterMap;
+  givens;
   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) {
     this.packageName = packageName;
     this.modelPath = modelPath;
     this.dataStyles = dataStyles;
@@ -230699,6 +231010,7 @@ class Model {
     this.runnableNotebookCells = runnableNotebookCells;
     this.compilationError = compilationError;
     this.filterMap = filterMap ?? new Map;
+    this.givens = givens;
     this.modelInfo = this.modelDef ? modelDefToModelInfo(this.modelDef) : undefined;
   }
   getFilters(sourceName) {
@@ -230719,10 +231031,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);
@@ -230755,7 +231071,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) {
@@ -230809,7 +231125,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) {
@@ -230873,12 +231189,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;
@@ -230932,7 +231248,8 @@ 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
     };
   }
   async getNotebookModel() {
@@ -230967,7 +231284,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       notebookCells
     };
   }
-  async executeNotebookCell(cellIndex, filterParams, bypassFilters) {
+  async executeNotebookCell(cellIndex, filterParams, bypassFilters, givens) {
     if (this.compilationError) {
       throw this.compilationError;
     }
@@ -231002,8 +231319,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));
@@ -231036,7 +231353,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
     };
   }
   static async getModelRuntime(packagePath, modelPath, malloyConfig, options) {
-    const fullModelPath = path6.join(packagePath, modelPath);
+    const fullModelPath = path7.join(packagePath, modelPath);
     try {
       if (!(await fs4.stat(fullModelPath)).isFile()) {
         throw new ModelNotFoundError(`${modelPath} is not a file.`);
@@ -231080,7 +231397,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;
@@ -231125,7 +231442,8 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
         name: sourceName,
         annotations,
         views,
-        filters
+        filters,
+        givens
       };
     });
     return { sources, filterMap };
@@ -231249,7 +231567,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
     return this.modelType;
   }
   async getFileText(packagePath) {
-    const fullPath = path6.join(packagePath, this.modelPath);
+    const fullPath = path7.join(packagePath, this.modelPath);
     try {
       return await fs4.readFile(fullPath, "utf8");
     } catch {
@@ -231258,6 +231576,167 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
   }
 }
 
+// src/service/schema_worker_pool.ts
+import { Worker } from "worker_threads";
+var DEFAULT_POOL_SIZE = 2;
+
+class SchemaWorkerPool {
+  workerUrl;
+  size;
+  workers = [];
+  queue = [];
+  inFlight = new Map;
+  workerCurrentId = new Map;
+  nextId = 1;
+  stopped = false;
+  constructor(workerUrl, size = DEFAULT_POOL_SIZE) {
+    this.workerUrl = workerUrl;
+    this.size = size;
+  }
+  start() {
+    if (this.workers.length > 0)
+      return;
+    for (let i = 0;i < this.size; i++) {
+      this.workers.push(this.spawn(i));
+    }
+    logger.info(`SchemaWorkerPool started (size=${this.size})`);
+  }
+  async stop() {
+    this.stopped = true;
+    const shutdownError = new Error("SchemaWorkerPool stopped");
+    for (const req of this.queue.splice(0))
+      req.reject(shutdownError);
+    for (const req of this.inFlight.values())
+      req.reject(shutdownError);
+    this.inFlight.clear();
+    await Promise.all(this.workers.map(async (slot) => {
+      try {
+        await slot.worker.terminate();
+      } catch {}
+    }));
+    this.workers.length = 0;
+  }
+  submit(packagePath, databasePath) {
+    if (this.stopped) {
+      return Promise.reject(new Error("SchemaWorkerPool stopped"));
+    }
+    if (this.workers.length === 0) {
+      return Promise.reject(new Error("SchemaWorkerPool.submit called before start()"));
+    }
+    return new Promise((resolve4, reject) => {
+      const req = {
+        id: this.nextId++,
+        packagePath,
+        databasePath,
+        resolve: resolve4,
+        reject
+      };
+      this.queue.push(req);
+      this.drain();
+    });
+  }
+  drain() {
+    for (let i = 0;i < this.workers.length; i++) {
+      if (this.queue.length === 0)
+        return;
+      const slot = this.workers[i];
+      if (slot.busy)
+        continue;
+      const req = this.queue.shift();
+      slot.busy = true;
+      this.inFlight.set(req.id, req);
+      this.workerCurrentId.set(i, req.id);
+      slot.worker.postMessage({
+        id: req.id,
+        packagePath: req.packagePath,
+        databasePath: req.databasePath
+      });
+    }
+  }
+  spawn(index) {
+    const worker = new Worker(this.workerUrl);
+    const slot = { worker, busy: false };
+    worker.on("message", (msg) => {
+      const req = this.inFlight.get(msg.id);
+      if (!req) {
+        logger.warn("SchemaWorkerPool: response for unknown request", {
+          id: msg.id,
+          workerIndex: index
+        });
+        return;
+      }
+      this.inFlight.delete(msg.id);
+      this.workerCurrentId.delete(index);
+      slot.busy = false;
+      if (msg.ok && msg.result) {
+        req.resolve(msg.result);
+      } else {
+        const err = new Error(msg.error?.message ?? "Unknown error");
+        if (msg.error?.stack)
+          err.stack = msg.error.stack;
+        req.reject(err);
+      }
+      this.drain();
+    });
+    worker.on("error", (err) => {
+      const inFlightId = this.workerCurrentId.get(index);
+      if (inFlightId !== undefined) {
+        const req = this.inFlight.get(inFlightId);
+        if (req) {
+          this.inFlight.delete(inFlightId);
+          req.reject(err);
+        }
+        this.workerCurrentId.delete(index);
+      }
+      logger.error("SchemaWorkerPool: worker errored, respawning", {
+        workerIndex: index,
+        error: err
+      });
+      if (!this.stopped) {
+        this.workers[index] = this.spawn(index);
+        this.drain();
+      }
+    });
+    worker.on("exit", (code) => {
+      if (this.stopped)
+        return;
+      if (code !== 0) {
+        logger.warn("SchemaWorkerPool: worker exited unexpectedly", {
+          workerIndex: index,
+          code
+        });
+        const inFlightId = this.workerCurrentId.get(index);
+        if (inFlightId !== undefined) {
+          const req = this.inFlight.get(inFlightId);
+          if (req) {
+            this.inFlight.delete(inFlightId);
+            req.reject(new Error(`SchemaWorker exited with code ${code}`));
+          }
+          this.workerCurrentId.delete(index);
+        }
+        this.workers[index] = this.spawn(index);
+        this.drain();
+      }
+    });
+    return slot;
+  }
+}
+var singleton = null;
+function getSchemaWorkerPool() {
+  if (!singleton) {
+    const url2 = resolveWorkerUrl();
+    const size = Number(process.env.PUBLISHER_SCHEMA_WORKER_POOL_SIZE) || 2;
+    singleton = new SchemaWorkerPool(url2, size);
+    singleton.start();
+  }
+  return singleton;
+}
+function resolveWorkerUrl() {
+  const base = new URL(import.meta.url);
+  const isBundled = base.pathname.endsWith(".mjs");
+  return new URL(isBundled ? "./service/schema_worker.mjs" : "./schema_worker.ts", base);
+}
+
 // src/service/package.ts
 var ENABLE_LIST_MODEL_COMPILATION = true;
 
@@ -231291,6 +231770,7 @@ class Package {
       packageName,
       duration: formatDuration(manifestValidationTime - startTime)
     });
+    let packageMalloyConfig;
     try {
       const packageConfig = await Package.readPackageConfig(packagePath);
       const packageConfigTime = performance.now();
@@ -231351,6 +231831,13 @@ class Package {
         malloy_package_name: packageName,
         status: "error"
       });
+      if (packageMalloyConfig) {
+        try {
+          await packageMalloyConfig.shutdown("close");
+        } catch (releaseError) {
+          logger.warn(`Failed to release package-local DuckDB for ${packageName}`, { error: releaseError });
+        }
+      }
       try {
         await fs5.rm(packagePath, {
           recursive: true,
@@ -231484,17 +231971,17 @@ class Package {
   static async getModelPaths(packagePath) {
     let files = undefined;
     try {
-      files = await import_recursive_readdir.default(packagePath);
+      files = await import_recursive_readdir.default(packagePath, [ignoreDotfiles]);
     } catch (error) {
       logger.error(error);
       throw new PackageNotFoundError(`Package config for ${packagePath} does not exist.`);
     }
     return files.map((fullPath) => {
-      return path7.relative(packagePath, fullPath).replace(/\\/g, "/");
+      return path8.relative(packagePath, fullPath).replace(/\\/g, "/");
     }).filter((modelPath) => modelPath.endsWith(MODEL_FILE_SUFFIX) || modelPath.endsWith(NOTEBOOK_FILE_SUFFIX));
   }
   static async validatePackageManifestExistsOrThrowError(packagePath) {
-    const packageConfigPath = path7.join(packagePath, PACKAGE_MANIFEST_NAME);
+    const packageConfigPath = path8.join(packagePath, PACKAGE_MANIFEST_NAME);
     try {
       await fs5.stat(packageConfigPath);
     } catch {
@@ -231503,7 +231990,7 @@ class Package {
     }
   }
   static async readPackageConfig(packagePath) {
-    const packageConfigPath = path7.join(packagePath, PACKAGE_MANIFEST_NAME);
+    const packageConfigPath = path8.join(packagePath, PACKAGE_MANIFEST_NAME);
     const packageConfigContents = await fs5.readFile(packageConfigPath);
     const packageManifest = JSON.parse(packageConfigContents.toString());
     return {
@@ -231512,40 +231999,36 @@ class Package {
     };
   }
   static async readDatabases(packagePath) {
-    return await Promise.all((await Package.getDatabasePaths(packagePath)).map(async (databasePath) => {
-      const databaseInfo = await Package.getDatabaseInfo(packagePath, databasePath);
-      return {
-        path: databasePath,
-        info: databaseInfo,
-        type: "embedded"
-      };
-    }));
+    const databasePaths = await Package.getDatabasePaths(packagePath);
+    if (databasePaths.length === 0)
+      return [];
+    const pool = getSchemaWorkerPool();
+    const settled = await Promise.allSettled(databasePaths.map((databasePath) => pool.submit(packagePath, databasePath)));
+    const results = [];
+    for (let i = 0;i < settled.length; i++) {
+      const outcome = settled[i];
+      if (outcome.status === "fulfilled") {
+        results.push({
+          path: databasePaths[i],
+          info: outcome.value,
+          type: "embedded"
+        });
+      } else {
+        logger.warn("Schema introspection failed for database", {
+          packagePath,
+          databasePath: databasePaths[i],
+          error: outcome.reason
+        });
+      }
+    }
+    return results;
   }
   static async getDatabasePaths(packagePath) {
-    let files = undefined;
-    files = await import_recursive_readdir.default(packagePath);
+    const files = await import_recursive_readdir.default(packagePath, [ignoreDotfiles]);
     return files.map((fullPath) => {
-      return path7.relative(packagePath, fullPath).replace(/\\/g, "/");
+      return path8.relative(packagePath, fullPath).replace(/\\/g, "/");
     }).filter((modelPath) => modelPath.endsWith(".parquet") || modelPath.endsWith(".csv"));
   }
-  static async getDatabaseInfo(packagePath, databasePath) {
-    const fullPath = path7.join(packagePath, databasePath);
-    const runtime = new ConnectionRuntime({
-      urlReader: new EmptyURLReader,
-      connections: [new DuckDBConnection3("duckdb")]
-    });
-    const normalizedPath = fullPath.replace(/\\/g, "/");
-    const model = runtime.loadModel(`source: temp is duckdb.table('${normalizedPath}')`);
-    const modelDef = await model.getModel();
-    const fields = modelDef._modelDef.contents["temp"].fields;
-    const schema = fields.map((field) => {
-      return { type: field.type, name: field.name };
-    });
-    const runner = model.loadQuery("run: temp->{aggregate: row_count is count()}");
-    const result = await runner.run();
-    const rowCount = result.data.value[0].row_count?.valueOf();
-    return { name: databasePath, rowCount, columns: schema };
-  }
   setName(name) {
     this.packageName = name;
   }
@@ -231558,6 +232041,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 {
@@ -231571,7 +232056,9 @@ class Environment {
   environmentPath;
   environmentName;
   metadata;
+  memoryGovernor = null;
   constructor(environmentName, environmentPath, malloyConfig, apiConnections) {
+    assertSafeEnvironmentPath(environmentPath);
     this.environmentName = environmentName;
     this.environmentPath = environmentPath;
     this.malloyConfig = malloyConfig;
@@ -231586,7 +232073,7 @@ class Environment {
   async writeEnvironmentReadme(readme) {
     if (readme === undefined)
       return;
-    const readmePath = path8.join(this.environmentPath, "README.md");
+    const readmePath = path9.join(this.environmentPath, "README.md");
     try {
       await fs6.promises.writeFile(readmePath, readme, "utf-8");
       logger.info(`Updated README.md for environment ${this.environmentName}`);
@@ -231628,12 +232115,13 @@ class Environment {
       apiConnections: malloyConfig.apiConnections
     });
     const environment = new Environment(environmentName, environmentPath, malloyConfig, malloyConfig.apiConnections);
+    await Environment.sweepStaleInstallDirs(environmentPath);
     return environment;
   }
   async reloadEnvironmentMetadata() {
     let readme = "";
     try {
-      readme = (await fs6.promises.readFile(path8.join(this.environmentPath, README_NAME))).toString();
+      readme = (await fs6.promises.readFile(path9.join(this.environmentPath, README_NAME))).toString();
     } catch {}
     this.metadata = {
       ...this.metadata,
@@ -231643,47 +232131,51 @@ class Environment {
     };
     return this.metadata;
   }
-  async compileSource(packageName, modelName, source, includeSql = false) {
-    const modelDir = path8.dirname(path8.join(this.environmentPath, packageName, modelName));
-    const virtualUri = `file://${path8.join(modelDir, "__compile_check.malloy")}`;
-    const virtualUrl = new URL(virtualUri);
-    const modelPath = path8.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);
         }
-        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 };
+        }
+        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;
@@ -231759,58 +232251,103 @@ ${source}` : source;
       throw error;
     }
   }
-  async getPackage(packageName, reload = false) {
+  getOrCreatePackageMutex(packageName) {
+    let packageMutex = this.packageMutexes.get(packageName);
+    if (packageMutex === undefined) {
+      packageMutex = new Mutex;
+      this.packageMutexes.set(packageName, packageMutex);
+    }
+    return packageMutex;
+  }
+  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;
     }
-    let packageMutex = this.packageMutexes.get(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) {
-        logger.debug(`Package ${packageName} loaded by another request`);
-        return existingPackage;
-      }
-    }
-    packageMutex = new Mutex;
-    this.packageMutexes.set(packageName, packageMutex);
-    return packageMutex.runExclusive(async () => {
-      const existingPackage = this.packages.get(packageName);
-      if (existingPackage !== undefined && !reload) {
-        return existingPackage;
-      }
-      this.setPackageStatus(packageName, "loading" /* LOADING */);
-      try {
-        logger.debug(`Loading package ${packageName}...`);
-        const packagePath = path8.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.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;
+    }
+    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 = path8.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
     });
+    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;
+    }
     this.setPackageStatus(packageName, "loading" /* LOADING */);
     try {
       this.packages.set(packageName, await Package.create(this.environmentName, packageName, packagePath, () => this.malloyConfig.malloyConfig));
@@ -231822,9 +232359,90 @@ ${source}` : source;
     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);
+      }
+      let newPackage;
+      try {
+        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 err;
+      }
+      this.packages.set(packageName, newPackage);
+      this.setPackageStatus(packageName, "serving" /* SERVING */);
+      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 = path8.join(this.environmentPath, packageName);
-    const manifestPath = path8.join(packagePath, "publisher.json");
+    const packagePath = safeJoinUnderRoot(this.environmentPath, packageName);
+    const manifestPath = safeJoinUnderRoot(packagePath, "publisher.json");
     try {
       let existingManifest = {};
       try {
@@ -231846,24 +232464,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);
@@ -231880,35 +232501,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(path8.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;
@@ -231960,7 +232595,7 @@ ${source}` : source;
     };
   }
   async deleteDuckDBConnection(connectionName) {
-    const duckdbPath = path8.join(this.environmentPath, `${connectionName}.duckdb`);
+    const duckdbPath = path9.join(this.environmentPath, `${connectionName}.duckdb`);
     try {
       await fs6.promises.rm(duckdbPath, { force: true });
       logger.info(`Removed DuckDB connection file ${connectionName} from environment ${this.environmentName}`);
@@ -232034,18 +232669,25 @@ class EnvironmentStore {
     followRegionRedirects: true
   });
   gcsClient;
+  memoryGovernor = null;
   constructor(serverRootPath) {
     this.serverRootPath = serverRootPath;
     this.gcsClient = new Storage;
     const storageConfig = {
       type: "duckdb",
       duckdb: {
-        path: path9.join(serverRootPath, "publisher.db")
+        path: path10.join(serverRootPath, "publisher.db")
       }
     };
     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({
@@ -232106,6 +232748,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 */);
@@ -232327,7 +232970,7 @@ class EnvironmentStore {
     const reInit = process.env.INITIALIZE_STORAGE === "true";
     await fs7.promises.mkdir(this.serverRootPath, { recursive: true });
     if (reInit) {
-      const uploadDocsPath2 = path9.join(this.serverRootPath, PUBLISHER_DATA_DIR);
+      const uploadDocsPath2 = path10.join(this.serverRootPath, PUBLISHER_DATA_DIR);
       logger.info(`Reinitialization mode: Cleaning up upload documents path ${uploadDocsPath2}`);
       try {
         await fs7.promises.rm(uploadDocsPath2, {
@@ -232344,7 +232987,7 @@ class EnvironmentStore {
     } else {
       logger.info(`Using existing publisher path`);
     }
-    const uploadDocsPath = path9.join(this.serverRootPath, PUBLISHER_DATA_DIR);
+    const uploadDocsPath = path10.join(this.serverRootPath, PUBLISHER_DATA_DIR);
     await fs7.promises.mkdir(uploadDocsPath, { recursive: true });
   }
   async listEnvironments(skipInitializationCheck = false) {
@@ -232354,6 +232997,10 @@ class EnvironmentStore {
     return Promise.all(Array.from(this.environments.values()).map((environment) => environment.serialize()));
   }
   async getStatus() {
+    const memoryGovernorStatus = this.memoryGovernor?.getStatus() ?? null;
+    logger.info("Memory governor status", {
+      memoryGovernor: memoryGovernorStatus
+    });
     const status = {
       timestamp: Date.now(),
       environments: [],
@@ -232457,6 +233104,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;
@@ -232576,12 +233224,12 @@ class EnvironmentStore {
     const absoluteEnvironmentPath = `${this.serverRootPath}/${PUBLISHER_DATA_DIR}/${environmentName}`;
     await fs7.promises.mkdir(absoluteEnvironmentPath, { recursive: true });
     if (environment.readme) {
-      await fs7.promises.writeFile(path9.join(absoluteEnvironmentPath, "README.md"), environment.readme);
+      await fs7.promises.writeFile(path10.join(absoluteEnvironmentPath, "README.md"), environment.readme);
     }
     return absoluteEnvironmentPath;
   }
   isLocalPath(location) {
-    return location.startsWith("./") || location.startsWith("../") || location.startsWith("~/") || location.startsWith("/") || path9.isAbsolute(location);
+    return location.startsWith("./") || location.startsWith("../") || location.startsWith("~/") || location.startsWith("/") || path10.isAbsolute(location);
   }
   isGitHubURL(location) {
     return location.startsWith("https://github.com/") || location.startsWith("git@github.com:");
@@ -232622,7 +233270,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}`);
@@ -232637,7 +233285,7 @@ class EnvironmentStore {
             if (githubInfo && githubInfo.packagePath) {
               const subPathMatch = _package.location.match(/\/tree\/[^/]+\/(.+)$/);
               if (subPathMatch) {
-                sourcePath = path9.join(tempDownloadPath, subPathMatch[1]);
+                sourcePath = path10.join(tempDownloadPath, subPathMatch[1]);
               } else {
                 sourcePath = tempDownloadPath;
               }
@@ -232648,7 +233296,7 @@ class EnvironmentStore {
             if (this.isLocalPath(_package.location)) {
               sourcePath = _package.location;
             } else {
-              sourcePath = path9.join(tempDownloadPath, groupedLocation);
+              sourcePath = path10.join(tempDownloadPath, groupedLocation);
             }
           }
           const sourceExists = await fs7.promises.access(sourcePath).then(() => true).catch(() => false);
@@ -232724,7 +233372,7 @@ class EnvironmentStore {
       }
     }
     if (this.isLocalPath(location)) {
-      const packagePath = path9.isAbsolute(location) ? location : path9.join(this.serverRootPath, location);
+      const packagePath = path10.isAbsolute(location) ? location : path10.join(this.serverRootPath, location);
       try {
         logger.info(`Mounting local directory at "${packagePath}" to "${targetPath}"`);
         await this.mountLocalDirectory(packagePath, targetPath, environmentName, packageName);
@@ -232778,11 +233426,11 @@ class EnvironmentStore {
     }
     await Promise.all(files.map(async (file) => {
       const relativeFilePath = file.name.replace(prefix, "");
-      const absoluteFilePath = isCompressedFile ? absoluteDirPath : path9.join(absoluteDirPath, relativeFilePath);
+      const absoluteFilePath = isCompressedFile ? absoluteDirPath : path10.join(absoluteDirPath, relativeFilePath);
       if (file.name.endsWith("/")) {
         return;
       }
-      await fs7.promises.mkdir(path9.dirname(absoluteFilePath), {
+      await fs7.promises.mkdir(path10.dirname(absoluteFilePath), {
         recursive: true
       });
       return fs7.promises.writeFile(absoluteFilePath, await file.download());
@@ -232798,7 +233446,7 @@ class EnvironmentStore {
     const prefix = prefixParts.join("/");
     if (isCompressedFile) {
       const zipFilePath = `${absoluteDirPath}.zip`;
-      await fs7.promises.mkdir(path9.dirname(zipFilePath), {
+      await fs7.promises.mkdir(path10.dirname(zipFilePath), {
         recursive: true
       });
       const command = new import_client_s32.GetObjectCommand({
@@ -232811,9 +233459,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}`);
@@ -232837,8 +233485,8 @@ class EnvironmentStore {
       if (!relativeFilePath || relativeFilePath.endsWith("/")) {
         return;
       }
-      const absoluteFilePath = path9.join(absoluteDirPath, relativeFilePath);
-      await fs7.promises.mkdir(path9.dirname(absoluteFilePath), {
+      const absoluteFilePath = path10.join(absoluteDirPath, relativeFilePath);
+      await fs7.promises.mkdir(path10.dirname(absoluteFilePath), {
         recursive: true
       });
       const command = new import_client_s32.GetObjectCommand({
@@ -232851,9 +233499,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}`);
@@ -232886,21 +233534,21 @@ 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) {
       logger.info(`Successfully cloned entire repository to: ${absoluteDirPath}`);
       return;
     }
-    const packageFullPath = path9.join(absoluteDirPath, cleanPackagePath);
+    const packageFullPath = path10.join(absoluteDirPath, cleanPackagePath);
     const packageExists = await fs7.promises.access(packageFullPath).then(() => true).catch(() => false);
     if (!packageExists) {
       throw new Error(`Package path "${cleanPackagePath}" does not exist in the cloned repository.`);
@@ -232908,7 +233556,7 @@ class EnvironmentStore {
     const dirContents = await fs7.promises.readdir(absoluteDirPath);
     for (const entry of dirContents) {
       if (entry !== cleanPackagePath.replace(/^\/+/, "").split("/")[0]) {
-        await fs7.promises.rm(path9.join(absoluteDirPath, entry), {
+        await fs7.promises.rm(path10.join(absoluteDirPath, entry), {
           recursive: true,
           force: true
         });
@@ -232916,7 +233564,7 @@ class EnvironmentStore {
     }
     const packageContents = await fs7.promises.readdir(packageFullPath);
     for (const entry of packageContents) {
-      await fs7.promises.rename(path9.join(packageFullPath, entry), path9.join(absoluteDirPath, entry));
+      await fs7.promises.rename(path10.join(packageFullPath, entry), path10.join(absoluteDirPath, entry));
     }
     await fs7.promises.rm(packageFullPath, { recursive: true, force: true });
   }
@@ -232964,9 +233612,9 @@ class WatchModeController {
       });
       return;
     }
-    this.watchingPath = path10.join(this.environmentStore.serverRootPath, watchName);
+    this.watchingPath = path11.join(this.environmentStore.serverRootPath, watchName);
     this.watcher = esm_default.watch(this.watchingPath, {
-      ignored: (path11, stats) => !!stats?.isFile() && !path11.endsWith(".malloy") && !path11.endsWith(".md"),
+      ignored: (path12, stats) => !!stats?.isFile() && !path12.endsWith(".malloy") && !path12.endsWith(".md"),
       ignoreInitial: true
     });
     const reloadEnvironment = async () => {
@@ -232974,16 +233622,16 @@ class WatchModeController {
       await this.environmentStore.addEnvironment(environment2.metadata);
       logger.info(`Reloaded environment ${watchName}`);
     };
-    this.watcher.on("add", async (path11) => {
-      logger.info(`Detected new file ${path11}, reloading environment ${watchName}`);
+    this.watcher.on("add", async (path12) => {
+      logger.info(`Detected new file ${path12}, reloading environment ${watchName}`);
       await reloadEnvironment();
     });
-    this.watcher.on("unlink", async (path11) => {
-      logger.info(`Detected deletion of ${path11}, reloading environment ${watchName}`);
+    this.watcher.on("unlink", async (path12) => {
+      logger.info(`Detected deletion of ${path12}, reloading environment ${watchName}`);
       await reloadEnvironment();
     });
-    this.watcher.on("change", async (path11) => {
-      logger.info(`Detected change on ${path11}, reloading environment ${watchName}`);
+    this.watcher.on("change", async (path12) => {
+      logger.info(`Detected change on ${path12}, reloading environment ${watchName}`);
       await reloadEnvironment();
     });
     res.json();
@@ -233289,7 +233937,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"));
@@ -233340,7 +233988,7 @@ class Protocol {
         }
         try {
           const result = resultSchema.parse(response.result);
-          resolve3(result);
+          resolve4(result);
         } catch (error) {
           reject(error);
         }
@@ -236074,25 +236722,25 @@ async function getModelForQuery(environmentStore, environmentName, packageName,
   }
 }
 function buildMalloyUri(components, fragment) {
-  let path11 = "/environment/";
+  let path12 = "/environment/";
   if (components.environment) {
-    path11 += encodeURIComponent(components.environment);
+    path12 += encodeURIComponent(components.environment);
   } else {
-    path11 += "home";
+    path12 += "home";
   }
   if (components.package) {
-    path11 += "/package/" + encodeURIComponent(components.package);
+    path12 += "/package/" + encodeURIComponent(components.package);
   }
   if (components.resourceType) {
-    path11 += "/" + components.resourceType;
+    path12 += "/" + components.resourceType;
     if (components.resourceName) {
-      path11 += "/" + encodeURIComponent(components.resourceName);
+      path12 += "/" + encodeURIComponent(components.resourceName);
       if (components.subResourceType && components.subResourceName) {
-        path11 += "/" + components.subResourceType + "/" + encodeURIComponent(components.subResourceName);
+        path12 += "/" + components.subResourceType + "/" + encodeURIComponent(components.subResourceName);
       }
     }
   }
-  let uriString = "malloy:/" + path11;
+  let uriString = "malloy:/" + path12;
   if (fragment) {
     uriString += "#" + fragment;
   }
@@ -236742,7 +237390,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: [
@@ -236805,7 +237453,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) => {
@@ -236816,7 +237465,8 @@ function registerExecuteQueryTool(mcpServer, environmentStore) {
       query,
       sourceName,
       queryName,
-      filterParams
+      filterParams,
+      givens
     } = params;
     logger.info("[MCP Tool executeQuery] Received params:", { params });
     const hasAdhocQuery = !!query;
@@ -236852,7 +237502,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 = {
@@ -236888,7 +237538,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 = {
@@ -236989,16 +237639,6 @@ function initializeMcpServer(environmentStore) {
 // src/server-old.ts
 var import_body_parser = __toESM(require_body_parser(), 1);
 var LEGACY_API_PREFIX = "/api/v0";
-function remapStatusResponse(status) {
-  if (!status || typeof status !== "object")
-    return status;
-  const out = { ...status };
-  if ("environments" in out) {
-    out.projects = out.environments;
-    delete out.environments;
-  }
-  return out;
-}
 function remapMaterializationResponse(mat) {
   if (!mat || typeof mat !== "object")
     return mat;
@@ -237028,16 +237668,6 @@ function registerLegacyRoutes(app, controllers) {
     materializationController,
     manifestController
   } = controllers;
-  app.get(`${LEGACY_API_PREFIX}/status`, async (_req, res) => {
-    try {
-      const status = await environmentStore.getStatus();
-      res.status(200).json(remapStatusResponse(status));
-    } catch (error) {
-      logger.error("Error getting status", { error });
-      const { json, status } = internalErrorToHttpError(error);
-      res.status(status).json(json);
-    }
-  });
   app.get(`${LEGACY_API_PREFIX}/projects`, async (_req, res) => {
     try {
       res.status(200).json(await environmentStore.listEnvironments());
@@ -237602,8 +238232,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,
@@ -237631,8 +238261,8 @@ import {
 } from "@malloydata/malloy";
 
 // src/service/quoting.ts
-function quoteTablePath(path11, dialect) {
-  return path11.split(".").map((seg) => dialect.quoteTablePath(seg)).join(".");
+function quoteTablePath(path12, dialect) {
+  return path12.split(".").map((seg) => dialect.quoteTablePath(seg)).join(".");
 }
 function splitTablePath(tableName) {
   const lastDot = tableName.lastIndexOf(".");
@@ -237924,8 +238554,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,
@@ -238015,7 +238645,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 };
@@ -238220,6 +238850,219 @@ class MaterializationService {
   }
 }
 
+// src/service/package_memory_governor.ts
+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/service/process_stats_reporter.ts
+import * as fs8 from "fs";
+var DEFAULT_INTERVAL_MS = 30000;
+function readLinuxProcStatus() {
+  try {
+    const raw = fs8.readFileSync("/proc/self/status", "utf8");
+    const out = {};
+    for (const line of raw.split(`
+`)) {
+      const [keyRaw, valueRaw] = line.split(":");
+      if (!keyRaw || !valueRaw)
+        continue;
+      const key = keyRaw.trim();
+      const value = valueRaw.trim();
+      switch (key) {
+        case "Threads":
+          out.threads = Number(value);
+          break;
+        case "VmRSS":
+          out.vmRssBytes = kBToBytes(value);
+          break;
+        case "VmSize":
+          out.vmSizeBytes = kBToBytes(value);
+          break;
+        case "VmPeak":
+          out.vmPeakBytes = kBToBytes(value);
+          break;
+        case "VmData":
+          out.vmDataBytes = kBToBytes(value);
+          break;
+        case "voluntary_ctxt_switches":
+          out.voluntaryCtxSwitches = Number(value);
+          break;
+        case "nonvoluntary_ctxt_switches":
+          out.nonvoluntaryCtxSwitches = Number(value);
+          break;
+      }
+    }
+    return out;
+  } catch {
+    return null;
+  }
+}
+function kBToBytes(value) {
+  const num = Number(value.replace(/\s*kB$/, ""));
+  if (!Number.isFinite(num))
+    return;
+  return num * 1024;
+}
+async function readBunJscStats() {
+  if (typeof globalThis.Bun === "undefined") {
+    return null;
+  }
+  try {
+    const jsc = await import("bun:jsc");
+    const heap = jsc.heapStats?.();
+    const mem = jsc.memoryUsage?.();
+    if (!heap && !mem)
+      return null;
+    return { ...heap ?? {}, ...mem ?? {} };
+  } catch {
+    return null;
+  }
+}
+
+class ProcessStatsReporter {
+  timer = null;
+  intervalMs;
+  memoryGovernor;
+  constructor(memoryGovernor, intervalMs = DEFAULT_INTERVAL_MS) {
+    this.memoryGovernor = memoryGovernor;
+    this.intervalMs = intervalMs;
+  }
+  start() {
+    if (this.timer !== null)
+      return;
+    this.tick();
+    this.timer = setInterval(() => void this.tick(), this.intervalMs);
+    this.timer.unref?.();
+    logger.info(`ProcessStatsReporter started (intervalMs=${this.intervalMs})`);
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  async tick() {
+    try {
+      const mem = process.memoryUsage();
+      const proc = process.platform === "linux" ? readLinuxProcStatus() : null;
+      const bun = await readBunJscStats();
+      const governor = this.memoryGovernor?.getStatus() ?? null;
+      logger.info("process stats", {
+        uptimeSeconds: Math.round(process.uptime()),
+        nodeMemory: {
+          rssBytes: mem.rss,
+          heapTotalBytes: mem.heapTotal,
+          heapUsedBytes: mem.heapUsed,
+          externalBytes: mem.external,
+          arrayBuffersBytes: mem.arrayBuffers
+        },
+        linux: proc,
+        bunJsc: bun,
+        memoryGovernor: governor
+      });
+    } catch (err) {
+      logger.warn("ProcessStatsReporter tick failed", { error: err });
+    }
+  }
+}
+
 // src/server.ts
 function normalizeQueryArray(value) {
   if (value === undefined || value === null)
@@ -238230,6 +239073,8 @@ function normalizeQueryArray(value) {
 }
 function parseArgs() {
   const args = process.argv.slice(2);
+  let sawServerRoot = false;
+  let sawConfig = false;
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--port" && args[i + 1]) {
@@ -238239,8 +239084,13 @@ function parseArgs() {
       process.env.PUBLISHER_HOST = args[i + 1];
       i++;
     } else if (arg === "--server_root" && args[i + 1]) {
+      sawServerRoot = true;
       process.env.SERVER_ROOT = args[i + 1];
       i++;
+    } else if (arg === "--config" && args[i + 1]) {
+      sawConfig = true;
+      process.env.PUBLISHER_CONFIG_PATH = args[i + 1];
+      i++;
     } else if (arg === "--mcp_port" && args[i + 1]) {
       process.env.MCP_PORT = args[i + 1];
       i++;
@@ -238261,6 +239111,7 @@ function parseArgs() {
       console.log("  --port <number>        Port to run the server on (default: 4000)");
       console.log("  --host <string>        Host to bind the server to (default: localhost)");
       console.log("  --server_root <path>   Root directory to serve files from (default: .)");
+      console.log("  --config <path>        Path to publisher.config.json (default: <server_root>/publisher.config.json; falls back to bundled DuckDB-only sample config if missing)");
       console.log("  --mcp_port <number>    Port for MCP server (default: 4040)");
       console.log("  --shutdown_drain_duration_seconds <number>  Time in seconds to keep service in draining state before closing servers (default: 0)");
       console.log("  --shutdown_graceful_close_timeout_seconds <number>  Time in seconds to wait after closing servers before exit (default: 0)");
@@ -238269,6 +239120,9 @@ function parseArgs() {
       process.exit(0);
     }
   }
+  if (!sawServerRoot && !sawConfig && true) {
+    process.env.PUBLISHER_USE_BUNDLED_DEFAULT = "true";
+  }
 }
 parseArgs();
 var PUBLISHER_PORT = Number(process.env.PUBLISHER_PORT || 4000);
@@ -238277,9 +239131,9 @@ var MCP_PORT = Number(process.env.MCP_PORT || 4040);
 var MCP_ENDPOINT = "/mcp";
 var SHUTDOWN_DRAIN_DURATION_SECONDS = Number(process.env.SHUTDOWN_DRAIN_DURATION_SECONDS || 0);
 var SHUTDOWN_GRACEFUL_CLOSE_TIMEOUT_SECONDS = Number(process.env.SHUTDOWN_GRACEFUL_CLOSE_TIMEOUT_SECONDS || 0);
-var __filename_esm = fileURLToPath2(import.meta.url);
-var ROOT = path11.join(path11.dirname(__filename_esm), "app");
-var SERVER_ROOT = path11.resolve(process.cwd(), process.env.SERVER_ROOT || ".");
+var __filename_esm = fileURLToPath3(import.meta.url);
+var ROOT = path12.join(path12.dirname(__filename_esm), "app");
+var SERVER_ROOT = path12.resolve(process.cwd(), process.env.SERVER_ROOT || ".");
 var API_PREFIX2 = "/api/v0";
 var isDevelopment = process.env["NODE_ENV"] === "development";
 var app = import_express.default();
@@ -238290,6 +239144,12 @@ 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 processStatsReporter = new ProcessStatsReporter(memoryGovernor);
+processStatsReporter.start();
 var packageController = new PackageController(environmentStore, manifestService);
 var databaseController = new DatabaseController(environmentStore);
 var queryController = new QueryController(environmentStore);
@@ -238360,14 +239220,14 @@ mcpApp.all(MCP_ENDPOINT, async (req, res) => {
 });
 if (!isDevelopment) {
   app.use("/", import_express.default.static(ROOT));
-  app.use("/api-doc.html", import_express.default.static(path11.join(ROOT, "api-doc.html")));
+  app.use("/api-doc.html", import_express.default.static(path12.join(ROOT, "api-doc.html")));
 } else {
   app.use(`${API_PREFIX2}`, loggerMiddleware);
   app.use(import_http_proxy_middleware.createProxyMiddleware({
     target: "http://localhost:5173",
     changeOrigin: true,
     ws: true,
-    pathFilter: (path12) => !path12.startsWith("/api/") && !path12.startsWith("/metrics") && !path12.startsWith("/health")
+    pathFilter: (path13) => !path13.startsWith("/api/") && !path13.startsWith("/metrics") && !path13.startsWith("/health")
   }));
 }
 var setVersionIdError2 = (res) => {
@@ -238808,7 +239668,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);
@@ -238836,7 +239707,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);
@@ -238858,7 +239729,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 });
@@ -238967,7 +239838,7 @@ registerLegacyRoutes(app, {
   manifestController
 });
 if (!isDevelopment) {
-  app.get("*", (_req, res) => res.sendFile(path11.resolve(ROOT, "index.html")));
+  app.get("*", (_req, res) => res.sendFile(path12.resolve(ROOT, "index.html")));
 }
 app.use((err, _req, res, _next) => {
   logger.error("Unhandled error:", err);