@forzalabs/remora 2.2.1 → 2.3.0

package/workers/ExecutorWorker.js

@@ -544,7 +544,7 @@ var require_has_flag = __commonJS({
 var require_supports_colors = __commonJS({
   "../../node_modules/@colors/colors/lib/system/supports-colors.js"(exports2, module2) {
     "use strict";
-    var os4 = require("os");
+    var os5 = require("os");
     var hasFlag = require_has_flag();
     var env2 = process.env;
     var forceColor = void 0;
@@ -582,7 +582,7 @@ var require_supports_colors = __commonJS({
       }
       var min = forceColor ? 1 : 0;
       if (process.platform === "win32") {
-        var osRelease = os4.release().split(".");
+        var osRelease = os5.release().split(".");
         if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -5827,7 +5827,7 @@ var require_winston_transport = __commonJS({
 var require_console = __commonJS({
   "../../node_modules/winston/lib/winston/transports/console.js"(exports2, module2) {
     "use strict";
-    var os4 = require("os");
+    var os5 = require("os");
     var { LEVEL, MESSAGE } = require_triple_beam();
     var TransportStream = require_winston_transport();
     module2.exports = class Console extends TransportStream {
@@ -5841,7 +5841,7 @@ var require_console = __commonJS({
         this.name = options2.name || "console";
         this.stderrLevels = this._stringArrayToSet(options2.stderrLevels);
         this.consoleWarnLevels = this._stringArrayToSet(options2.consoleWarnLevels);
-        this.eol = typeof options2.eol === "string" ? options2.eol : os4.EOL;
+        this.eol = typeof options2.eol === "string" ? options2.eol : os5.EOL;
         this.forceConsole = options2.forceConsole || false;
         this._consoleLog = console.log.bind(console);
         this._consoleWarn = console.warn.bind(console);
@@ -7900,15 +7900,15 @@ var require_index_cjs = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path20 = [graph[toModel].parent, toModel];
+      const path22 = [graph[toModel].parent, toModel];
       let fn = convert$1[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path20.unshift(graph[cur].parent);
+        path22.unshift(graph[cur].parent);
         fn = link(convert$1[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path20;
+      fn.conversion = path22;
       return fn;
     }
     function route(fromModel) {
@@ -8538,7 +8538,7 @@ var require_node2 = __commonJS({
 var require_tail_file = __commonJS({
   "../../node_modules/winston/lib/winston/tail-file.js"(exports2, module2) {
     "use strict";
-    var fs28 = require("fs");
+    var fs31 = require("fs");
     var { StringDecoder } = require("string_decoder");
     var { Stream } = require_readable();
     function noop() {
@@ -8559,7 +8559,7 @@ var require_tail_file = __commonJS({
         stream.emit("end");
         stream.emit("close");
       };
-      fs28.open(options2.file, "a+", "0644", (err2, fd) => {
+      fs31.open(options2.file, "a+", "0644", (err2, fd) => {
         if (err2) {
           if (!iter) {
             stream.emit("error", err2);
@@ -8571,10 +8571,10 @@ var require_tail_file = __commonJS({
         }
         (function read() {
           if (stream.destroyed) {
-            fs28.close(fd, noop);
+            fs31.close(fd, noop);
             return;
           }
-          return fs28.read(fd, buffer, 0, buffer.length, pos, (error, bytes) => {
+          return fs31.read(fd, buffer, 0, buffer.length, pos, (error, bytes) => {
             if (error) {
               if (!iter) {
                 stream.emit("error", error);
@@ -8633,15 +8633,15 @@ var require_tail_file = __commonJS({
 var require_file = __commonJS({
   "../../node_modules/winston/lib/winston/transports/file.js"(exports2, module2) {
     "use strict";
-    var fs28 = require("fs");
-    var path20 = require("path");
+    var fs31 = require("fs");
+    var path22 = require("path");
     var asyncSeries = require_series();
     var zlib3 = require("zlib");
     var { MESSAGE } = require_triple_beam();
     var { Stream, PassThrough } = require_readable();
     var TransportStream = require_winston_transport();
     var debug = require_node2()("winston:file");
-    var os4 = require("os");
+    var os5 = require("os");
     var tailFile = require_tail_file();
     module2.exports = class File extends TransportStream {
       /**
@@ -8664,14 +8664,14 @@ var require_file = __commonJS({
         this._onError = this._onError.bind(this);
         if (options2.filename || options2.dirname) {
           throwIf("filename or dirname", "stream");
-          this._basename = this.filename = options2.filename ? path20.basename(options2.filename) : "winston.log";
-          this.dirname = options2.dirname || path20.dirname(options2.filename);
+          this._basename = this.filename = options2.filename ? path22.basename(options2.filename) : "winston.log";
+          this.dirname = options2.dirname || path22.dirname(options2.filename);
           this.options = options2.options || { flags: "a" };
         } else if (options2.stream) {
           console.warn("options.stream will be removed in winston@4. Use winston.transports.Stream");
           throwIf("stream", "filename", "maxsize");
           this._dest = this._stream.pipe(this._setupStream(options2.stream));
-          this.dirname = path20.dirname(this._dest.path);
+          this.dirname = path22.dirname(this._dest.path);
         } else {
           throw new Error("Cannot log to file without filename or stream.");
         }
@@ -8679,7 +8679,7 @@ var require_file = __commonJS({
         this.rotationFormat = options2.rotationFormat || false;
         this.zippedArchive = options2.zippedArchive || false;
         this.maxFiles = options2.maxFiles || null;
-        this.eol = typeof options2.eol === "string" ? options2.eol : os4.EOL;
+        this.eol = typeof options2.eol === "string" ? options2.eol : os5.EOL;
         this.tailable = options2.tailable || false;
         this.lazy = options2.lazy || false;
         this._size = 0;
@@ -8834,11 +8834,11 @@ var require_file = __commonJS({
           options2 = {};
         }
         options2 = normalizeQuery(options2);
-        const file = path20.join(this.dirname, this.filename);
+        const file = path22.join(this.dirname, this.filename);
         let buff = "";
         let results = [];
         let row = 0;
-        const stream = fs28.createReadStream(file, {
+        const stream = fs31.createReadStream(file, {
           encoding: "utf8"
         });
         stream.on("error", (err2) => {
@@ -8939,7 +8939,7 @@ var require_file = __commonJS({
        * TODO: Refactor me.
        */
       stream(options2 = {}) {
-        const file = path20.join(this.dirname, this.filename);
+        const file = path22.join(this.dirname, this.filename);
         const stream = new Stream();
         const tail = {
           file,
@@ -8989,8 +8989,8 @@ var require_file = __commonJS({
        */
       stat(callback) {
         const target = this._getFile();
-        const fullpath = path20.join(this.dirname, target);
-        fs28.stat(fullpath, (err2, stat) => {
+        const fullpath = path22.join(this.dirname, target);
+        fs31.stat(fullpath, (err2, stat) => {
           if (err2 && err2.code === "ENOENT") {
             debug("ENOENT\xA0ok", fullpath);
             this.filename = target;
@@ -9093,9 +9093,9 @@ var require_file = __commonJS({
        * @returns {WritableStream} Stream that writes to disk for the active file.
        */
       _createStream(source) {
-        const fullpath = path20.join(this.dirname, this.filename);
+        const fullpath = path22.join(this.dirname, this.filename);
         debug("create stream start", fullpath, this.options);
-        const dest = fs28.createWriteStream(fullpath, this.options).on("error", (err2) => debug(err2)).on("close", () => debug("close", dest.path, dest.bytesWritten)).on("open", () => {
+        const dest = fs31.createWriteStream(fullpath, this.options).on("error", (err2) => debug(err2)).on("close", () => debug("close", dest.path, dest.bytesWritten)).on("open", () => {
           debug("file open ok", fullpath);
           this.emit("open", fullpath);
           source.pipe(dest);
@@ -9118,16 +9118,16 @@ var require_file = __commonJS({
        */
       _incFile(callback) {
         debug("_incFile", this.filename);
-        const ext = path20.extname(this._basename);
-        const basename = path20.basename(this._basename, ext);
+        const ext = path22.extname(this._basename);
+        const basename = path22.basename(this._basename, ext);
         const tasks = [];
         if (this.zippedArchive) {
           tasks.push(
             function(cb) {
               const num = this._created > 0 && !this.tailable ? this._created : "";
               this._compressFile(
-                path20.join(this.dirname, `${basename}${num}${ext}`),
-                path20.join(this.dirname, `${basename}${num}${ext}.gz`),
+                path22.join(this.dirname, `${basename}${num}${ext}`),
+                path22.join(this.dirname, `${basename}${num}${ext}.gz`),
                 cb
               );
             }.bind(this)
@@ -9152,8 +9152,8 @@ var require_file = __commonJS({
        * @private
        */
       _getFile() {
-        const ext = path20.extname(this._basename);
-        const basename = path20.basename(this._basename, ext);
+        const ext = path22.extname(this._basename);
+        const basename = path22.basename(this._basename, ext);
         const isRotation = this.rotationFormat ? this.rotationFormat() : this._created;
         return !this.tailable && this._created ? `${basename}${isRotation}${ext}` : `${basename}${ext}`;
       }
@@ -9173,8 +9173,8 @@ var require_file = __commonJS({
         const isOldest = oldest !== 0 ? oldest : "";
         const isZipped = this.zippedArchive ? ".gz" : "";
         const filePath = `${basename}${isOldest}${ext}${isZipped}`;
-        const target = path20.join(this.dirname, filePath);
-        fs28.unlink(target, callback);
+        const target = path22.join(this.dirname, filePath);
+        fs31.unlink(target, callback);
       }
       /**
        * Roll files forward based on integer, up to maxFiles. e.g. if base if
@@ -9196,20 +9196,20 @@ var require_file = __commonJS({
         for (let x2 = this.maxFiles - 1; x2 > 1; x2--) {
           tasks.push(function(i6, cb) {
             let fileName = `${basename}${i6 - 1}${ext}${isZipped}`;
-            const tmppath = path20.join(this.dirname, fileName);
-            fs28.exists(tmppath, (exists) => {
+            const tmppath = path22.join(this.dirname, fileName);
+            fs31.exists(tmppath, (exists) => {
               if (!exists) {
                 return cb(null);
               }
               fileName = `${basename}${i6}${ext}${isZipped}`;
-              fs28.rename(tmppath, path20.join(this.dirname, fileName), cb);
+              fs31.rename(tmppath, path22.join(this.dirname, fileName), cb);
             });
           }.bind(this, x2));
         }
         asyncSeries(tasks, () => {
-          fs28.rename(
-            path20.join(this.dirname, `${basename}${ext}${isZipped}`),
-            path20.join(this.dirname, `${basename}1${ext}${isZipped}`),
+          fs31.rename(
+            path22.join(this.dirname, `${basename}${ext}${isZipped}`),
+            path22.join(this.dirname, `${basename}1${ext}${isZipped}`),
             callback
           );
         });
@@ -9223,22 +9223,22 @@ var require_file = __commonJS({
        * @private
        */
       _compressFile(src, dest, callback) {
-        fs28.access(src, fs28.F_OK, (err2) => {
+        fs31.access(src, fs31.F_OK, (err2) => {
           if (err2) {
             return callback();
           }
           var gzip = zlib3.createGzip();
-          var inp = fs28.createReadStream(src);
-          var out = fs28.createWriteStream(dest);
+          var inp = fs31.createReadStream(src);
+          var out = fs31.createWriteStream(dest);
           out.on("finish", () => {
-            fs28.unlink(src, callback);
+            fs31.unlink(src, callback);
           });
           inp.pipe(gzip).pipe(out);
         });
       }
       _createLogDirIfNotExist(dirPath) {
-        if (!fs28.existsSync(dirPath)) {
-          fs28.mkdirSync(dirPath, { recursive: true });
+        if (!fs31.existsSync(dirPath)) {
+          fs31.mkdirSync(dirPath, { recursive: true });
         }
       }
     };
@@ -9322,9 +9322,9 @@ var require_http = __commonJS({
         };
         const auth = options2.params.auth || null;
         delete options2.params.auth;
-        const path20 = options2.params.path || null;
+        const path22 = options2.params.path || null;
         delete options2.params.path;
-        this._request(options2, auth, path20, (err2, res, body) => {
+        this._request(options2, auth, path22, (err2, res, body) => {
           if (res && res.statusCode !== 200) {
             err2 = new Error(`Invalid HTTP Status Code: ${res.statusCode}`);
           }
@@ -9352,12 +9352,12 @@ var require_http = __commonJS({
           method: "stream",
           params: options2
         };
-        const path20 = options2.params.path || null;
+        const path22 = options2.params.path || null;
         delete options2.params.path;
         const auth = options2.params.auth || null;
         delete options2.params.auth;
         let buff = "";
-        const req = this._request(options2, auth, path20);
+        const req = this._request(options2, auth, path22);
         stream.destroy = () => req.destroy();
         req.on("data", (data) => {
           data = (buff + data).split(/\n+/);
@@ -9383,14 +9383,14 @@ var require_http = __commonJS({
        * @param {string} path - request path
        * @param {function} callback - Continuation to respond to when complete.
        */
-      _request(options2, auth, path20, callback) {
+      _request(options2, auth, path22, callback) {
         options2 = options2 || {};
         auth = auth || this.auth;
-        path20 = path20 || this.path || "";
+        path22 = path22 || this.path || "";
         if (this.batch) {
-          this._doBatch(options2, callback, auth, path20);
+          this._doBatch(options2, callback, auth, path22);
         } else {
-          this._doRequest(options2, callback, auth, path20);
+          this._doRequest(options2, callback, auth, path22);
         }
       }
       /**
@@ -9400,18 +9400,18 @@ var require_http = __commonJS({
        * @param {Object?} auth - authentication options
        * @param {string} path - request path
        */
-      _doBatch(options2, callback, auth, path20) {
+      _doBatch(options2, callback, auth, path22) {
         this.batchOptions.push(options2);
         if (this.batchOptions.length === 1) {
           const me3 = this;
           this.batchCallback = callback;
           this.batchTimeoutID = setTimeout(function() {
             me3.batchTimeoutID = -1;
-            me3._doBatchRequest(me3.batchCallback, auth, path20);
+            me3._doBatchRequest(me3.batchCallback, auth, path22);
           }, this.batchInterval);
         }
         if (this.batchOptions.length === this.batchCount) {
-          this._doBatchRequest(this.batchCallback, auth, path20);
+          this._doBatchRequest(this.batchCallback, auth, path22);
         }
       }
       /**
@@ -9420,14 +9420,14 @@ var require_http = __commonJS({
        * @param {Object?} auth - authentication options
        * @param {string} path - request path
        */
-      _doBatchRequest(callback, auth, path20) {
+      _doBatchRequest(callback, auth, path22) {
         if (this.batchTimeoutID > 0) {
           clearTimeout(this.batchTimeoutID);
           this.batchTimeoutID = -1;
         }
         const batchOptionsCopy = this.batchOptions.slice();
         this.batchOptions = [];
-        this._doRequest(batchOptionsCopy, callback, auth, path20);
+        this._doRequest(batchOptionsCopy, callback, auth, path22);
       }
       /**
        * Make a request to a winstond server or any http server which can
@@ -9437,7 +9437,7 @@ var require_http = __commonJS({
        * @param {Object?} auth - authentication options
        * @param {string} path - request path
        */
-      _doRequest(options2, callback, auth, path20) {
+      _doRequest(options2, callback, auth, path22) {
         const headers = Object.assign({}, this.headers);
         if (auth && auth.bearer) {
           headers.Authorization = `Bearer ${auth.bearer}`;
@@ -9447,7 +9447,7 @@ var require_http = __commonJS({
           method: "POST",
           host: this.host,
           port: this.port,
-          path: `/${path20.replace(/^\//, "")}`,
+          path: `/${path22.replace(/^\//, "")}`,
           headers,
           auth: auth && auth.username && auth.password ? `${auth.username}:${auth.password}` : "",
           agent: this.agent
@@ -9482,7 +9482,7 @@ var require_stream2 = __commonJS({
     "use strict";
     var isStream = require_is_stream();
     var { MESSAGE } = require_triple_beam();
-    var os4 = require("os");
+    var os5 = require("os");
     var TransportStream = require_winston_transport();
     module2.exports = class Stream extends TransportStream {
       /**
@@ -9498,7 +9498,7 @@ var require_stream2 = __commonJS({
         this._stream = options2.stream;
         this._stream.setMaxListeners(Infinity);
         this.isObjectMode = options2.stream._writableState.objectMode;
-        this.eol = typeof options2.eol === "string" ? options2.eol : os4.EOL;
+        this.eol = typeof options2.eol === "string" ? options2.eol : os5.EOL;
       }
       /**
        * Core logging method exposed to Winston.
@@ -9881,7 +9881,7 @@ var require_exception_stream = __commonJS({
 var require_exception_handler = __commonJS({
   "../../node_modules/winston/lib/winston/exception-handler.js"(exports2, module2) {
     "use strict";
-    var os4 = require("os");
+    var os5 = require("os");
     var asyncForEach = require_forEach();
     var debug = require_node2()("winston:exception");
     var once = require_one_time();
@@ -9976,8 +9976,8 @@ var require_exception_handler = __commonJS({
        */
       getOsInfo() {
         return {
-          loadavg: os4.loadavg(),
-          uptime: os4.uptime()
+          loadavg: os5.loadavg(),
+          uptime: os5.uptime()
         };
       }
       /**
@@ -10119,7 +10119,7 @@ var require_rejection_stream = __commonJS({
 var require_rejection_handler = __commonJS({
   "../../node_modules/winston/lib/winston/rejection-handler.js"(exports2, module2) {
     "use strict";
-    var os4 = require("os");
+    var os5 = require("os");
     var asyncForEach = require_forEach();
     var debug = require_node2()("winston:rejection");
     var once = require_one_time();
@@ -10216,8 +10216,8 @@ var require_rejection_handler = __commonJS({
        */
       getOsInfo() {
         return {
-          loadavg: os4.loadavg(),
-          uptime: os4.uptime()
+          loadavg: os5.loadavg(),
+          uptime: os5.uptime()
         };
       }
       /**
@@ -11809,7 +11809,7 @@ var CONSTANTS, Constants_default;
 var init_Constants = __esm({
   "../../packages/constants/src/Constants.ts"() {
     CONSTANTS = {
-      cliVersion: "2.2.1",
+      cliVersion: "2.3.0",
       backendVersion: 1,
       backendPort: 5088,
       workerVersion: 2,
@@ -11961,11 +11961,67 @@ var init_settings = __esm({
   }
 });
 
+// ../../packages/constants/src/environmentSettings.ts
+var EnvironmentSettingsClass, EnvironmentSettings, ENVIRONMENT_VARIABLES;
+var init_environmentSettings = __esm({
+  "../../packages/constants/src/environmentSettings.ts"() {
+    EnvironmentSettingsClass = class {
+      constructor() {
+        /**
+         * All the variables foundamental for operativity of remora
+         */
+        this.FOUNDAMENTAL = ["REMORA_LICENCE_KEY"];
+        /**
+         * All the variables that are not foundamental for the operativity of remora
+         */
+        this.BASIC = ["REMORA_KEY_SECRET", "REMORA_WORKERS_PATH", "ADMIN_JWT_SECRET", "JWT_SECRET", "ROOT_TEMP_PASSWORD", "REMORA_WORKER_HOST", "MONGO_URI", "REMORA_SALT", "OPENAI_API_KEY", "AWS_DEFAULT_REGION", "AWS_ACCOUNT_ID", "AWS_ACCESS_KEY_ID", "AWS_SESSION_TOKEN", "NODE_ENV", "REMORA_RUNTIME_CONTEXT", "REMORA_STATE_ENABLED", "REMORA_STATE_INTERVAL_MS", "REMORA_MAX_WORKERS", "REMORA_LOG_FORMAT"];
+        this.addFoundamentalVariables = (variable) => {
+          this.FOUNDAMENTAL.push(variable);
+        };
+        this.addEnvironmentVariables = (variable) => {
+          this.BASIC.push(variable);
+        };
+      }
+    };
+    EnvironmentSettings = new EnvironmentSettingsClass();
+    ENVIRONMENT_VARIABLES = [
+      "REMORA_STATE_ENABLED",
+      "REMORA_STATE_INTERVAL_MS",
+      "REMORA_KEY_SECRET",
+      "REMORA_LICENCE_KEY",
+      "INSTALLATION_ID",
+      "REMORA_WORKER_HOST",
+      "JWT_SECRET",
+      "ADMIN_JWT_SECRET",
+      "MONGO_URI",
+      "ROOT_TEMP_PASSWORD",
+      "REMORA_SALT",
+      "OPENAI_API_KEY",
+      "AWS_DEFAULT_REGION",
+      "AWS_ACCOUNT_ID",
+      "AWS_ACCESS_KEY_ID",
+      "AWS_SESSION_TOKEN",
+      "AWS_SECRET_ACCESS_KEY",
+      "NODE_ENV",
+      "REMORA_WORKERS_PATH",
+      "REMORA_CORS_ORIGINS",
+      "REMORA_DEBUG_MODE",
+      "REMORA_MASK_IN_DEV",
+      "BACKEND_ENDPOINT",
+      "REMORA_CONFIG_URI",
+      "REMORA_RUNTIME_CONTEXT",
+      "REMORA_MAX_WORKERS",
+      "REMORA_LOG_FORMAT"
+    ];
+  }
+});
+
 // ../../packages/constants/src/index.ts
 var init_src3 = __esm({
   "../../packages/constants/src/index.ts"() {
     init_Constants();
     init_settings();
+    init_environmentSettings();
   }
 });
 
@@ -12148,13 +12204,22 @@ var init_SecretManager = __esm({
     init_ProcessENVManager();
     SecretManagerClass = class {
       constructor() {
+        /**
+         * Whether a configured value NAMES an environment variable rather than holding one.
+         *
+         * The one place that decides what a reference is. `replaceSecret` reads it to know what to
+         * resolve, and `SecretRedactor` reads it to know what to leave alone — a `{AWS_ID}` is
+         * configuration and has to survive into a bug report, where which variable a source reads is
+         * exactly the question being asked.
+         */
+        this.isReference = (value) => !!value && value.length > 2 && value.startsWith("{") && value.endsWith("}");
         /**
          * If the value is a secret (or .env setting), replace it with the value inside the .env configuration file
          * Starts with "{" and ends with "}".
          * e.g. {AWS_ID}
          */
         this.replaceSecret = (value) => {
-          if (!value || value.length <= 2 || !value.startsWith("{") || !value.endsWith("}"))
+          if (!this.isReference(value))
             return value;
           const parsedValue = value.slice(1, value.length - 1);
           return ProcessENVManager_default.getEnvVariable(parsedValue);
@@ -12166,6 +12231,130 @@ var init_SecretManager = __esm({
   }
 });
 
+// ../../packages/common/src/SecretRedactor.ts
+var REDACTED2, TEXT_PATTERNS, unquote, SecretRedactorClass, SecretRedactor, SecretRedactor_default;
+var init_SecretRedactor = __esm({
+  "../../packages/common/src/SecretRedactor.ts"() {
+    init_SecretManager();
+    REDACTED2 = "[redacted]";
+    TEXT_PATTERNS = [
+      // A JWT in a log line is a working credential until it expires
+      {
+        pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
+        replace: () => REDACTED2
+      },
+      // An AWS access key id names the account it belongs to, and pairs with a secret in the same log
+      {
+        pattern: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+        replace: () => REDACTED2
+      },
+      // Any URL query string: a presigned URL carries its signature there, which is the credential
+      {
+        pattern: /(https?:\/\/[^\s"'<>]+?)\?[^\s"'<>]*/g,
+        replace: (_match, url) => `${url}?${REDACTED2}`
+      },
+      // `password=...`, `"apiKey": "..."`, `Authorization: Bearer ...` and the rest of the family.
+      // A bare `{ENV_VAR}` is its own alternative, and first: the general value class stops at `}`
+      // so that a `{"password":"x"}` match cannot swallow the closing brace of its own object, which
+      // left an unquoted reference matched as `{PG_PASSWORD` — not a reference, and redacted as if
+      // it held something.
+      {
+        pattern: /("?\b(?:password|secret|secret_key|secretKey|session_token|sessionToken|bearerToken|client_secret|clientSecret|api_key|apiKey|access_key|accessKey|token|authorization)\b"?\s*[:=]\s*)(Bearer\s+)?(\{[A-Za-z_][A-Za-z0-9_]*\}|"[^"]*"|'[^']*'|[^\s,;}&]+)/gi,
+        replace: (match, prefix2, bearer, value) => SecretManager_default.isReference(unquote(value)) ? match : `${prefix2}${bearer ?? ""}${REDACTED2}`
+      }
+    ];
+    unquote = (value) => value?.length > 1 && /^["']/.test(value) ? value.slice(1, -1) : value;
+    SecretRedactorClass = class {
+      constructor() {
+        /**
+         * The text with every credential shape above replaced. Pure: same input, same output, and the
+         * caller's string is never touched.
+         */
+        this.redactText = (text) => {
+          if (!text) return text;
+          return TEXT_PATTERNS.reduce(
+            (current, { pattern, replace }) => current.replace(pattern, replace),
+            text
+          );
+        };
+      }
+    };
+    SecretRedactor = new SecretRedactorClass();
+    SecretRedactor_default = SecretRedactor;
+  }
+});
+
+// ../../packages/common/src/ConfigPackager.ts
+var import_fs3, import_path3, import_adm_zip, EXCLUDED_ENTRIES, EXCLUDED_EXTENSIONS, ENV_FILE_PATTERN, ConfigPackagerClass, ConfigPackager, ConfigPackager_default;
+var init_ConfigPackager = __esm({
+  "../../packages/common/src/ConfigPackager.ts"() {
+    import_fs3 = __toESM(require("fs"), 1);
+    import_path3 = __toESM(require("path"), 1);
+    import_adm_zip = __toESM(require("adm-zip"), 1);
+    init_src();
+    EXCLUDED_ENTRIES = ["temp", ".temp", "logs", ".git", "node_modules", ".DS_Store"];
+    EXCLUDED_EXTENSIONS = [".log"];
+    ENV_FILE_PATTERN = /(^|\/)\.env(\.|$)/;
+    ConfigPackagerClass = class {
+      constructor() {
+        /**
+         * Build the deployment archive of a remora project directory.
+         *
+         * Entries are stored relative to the project root (`producers/p.json`, never
+         * `remora/producers/p.json`) because every consumer of this archive — the worker's
+         * `uploaddeployment` endpoint and a remote `REMORA_CONFIG_URI` — extracts it straight
+         * into the target's own `remora` directory.
+         */
+        this.build = (rootDir) => {
+          Affirm_default(rootDir, "Missing required parameter rootDir");
+          Affirm_default(import_fs3.default.existsSync(rootDir), `Missing configuration directory: ${rootDir}`);
+          const zip = new import_adm_zip.default();
+          this._addDirectory(zip, rootDir, "");
+          Affirm_default(zip.getEntries().length > 0, `No configuration files found in ${rootDir}`);
+          const envFile = zip.getEntries().find((entry) => ENV_FILE_PATTERN.test(entry.entryName));
+          Affirm_default(!envFile, `Environment file inside the configuration directory: ${envFile?.entryName}. It holds the values the configuration only names, and this archive is uploaded to a worker and packaged into bug reports \u2014 move it above the project directory.`);
+          return zip;
+        };
+        /** Build the archive of rootDir and write it to outputPath, replacing any file already there. */
+        this.write = (rootDir, outputPath) => {
+          Affirm_default(rootDir, "Missing required parameter rootDir");
+          Affirm_default(outputPath, "Missing required parameter outputPath");
+          const target = import_path3.default.resolve(outputPath);
+          Affirm_default(
+            !import_fs3.default.existsSync(target) || import_fs3.default.statSync(target).isFile(),
+            `Output path is not a file: ${target}`
+          );
+          const parent = import_path3.default.dirname(target);
+          Affirm_default(import_fs3.default.existsSync(parent), `Missing output directory: ${parent}`);
+          const zip = this.build(rootDir);
+          zip.writeZip(target);
+          return {
+            path: target,
+            files: zip.getEntries().length,
+            bytes: import_fs3.default.statSync(target).size
+          };
+        };
+        /** Whether an entry name is one the package never carries. */
+        this._isExcluded = (name) => EXCLUDED_ENTRIES.includes(name) || EXCLUDED_EXTENSIONS.some((ext) => name.endsWith(ext));
+        /** Add every file under directoryPath to the archive, recursively, under zipPath. */
+        this._addDirectory = (zip, directoryPath, zipPath) => {
+          for (const entry of import_fs3.default.readdirSync(directoryPath, { withFileTypes: true })) {
+            if (this._isExcluded(entry.name)) continue;
+            const fullPath = import_path3.default.join(directoryPath, entry.name);
+            const entryPath = zipPath ? `${zipPath}/${entry.name}` : entry.name;
+            if (entry.isDirectory())
+              this._addDirectory(zip, fullPath, entryPath);
+            else
+              zip.addFile(entryPath, import_fs3.default.readFileSync(fullPath));
+          }
+        };
+      }
+    };
+    ConfigPackager = new ConfigPackagerClass();
+    ConfigPackager_default = ConfigPackager;
+  }
+});
+
 // ../../packages/common/src/schema/SchemaErrorReporter.ts
 var MAX_REPORTED_ERRORS, MAX_LISTED_VALUES, MAX_QUOTED_LENGTH, VALUE_KEYWORDS, ITEM_NAME_KEYS, SchemaErrorReporterClass, SchemaErrorReporter, SchemaErrorReporter_default;
 var init_SchemaErrorReporter = __esm({
@@ -12293,13 +12482,13 @@ var init_SchemaErrorReporter = __esm({
 });
 
 // ../../packages/common/src/schema/SchemaValidator.ts
-var import_ajv, import_ajv_formats, import_fs3, import_path3, SchemaValidatorClass, SchemaValidator, SchemaValidator_default;
+var import_ajv, import_ajv_formats, import_fs4, import_path4, SchemaValidatorClass, SchemaValidator, SchemaValidator_default;
 var init_SchemaValidator = __esm({
   "../../packages/common/src/schema/SchemaValidator.ts"() {
     import_ajv = __toESM(require("ajv"), 1);
     import_ajv_formats = __toESM(require("ajv-formats"), 1);
-    import_fs3 = __toESM(require("fs"), 1);
-    import_path3 = __toESM(require("path"), 1);
+    import_fs4 = __toESM(require("fs"), 1);
+    import_path4 = __toESM(require("path"), 1);
     init_src();
     init_SchemaErrorReporter();
     SchemaValidatorClass = class {
@@ -12339,8 +12528,8 @@ var init_SchemaValidator = __esm({
             "code-set-schema"
           ];
           internalSchemas.forEach((sn2) => {
-            const sp = import_path3.default.join(internalSchemaDir, `${sn2}.json`);
-            const parsed = JSON.parse(import_fs3.default.readFileSync(sp, "utf-8"));
+            const sp = import_path4.default.join(internalSchemaDir, `${sn2}.json`);
+            const parsed = JSON.parse(import_fs4.default.readFileSync(sp, "utf-8"));
             this.addSchema(parsed, sn2);
           });
           return true;
@@ -12348,11 +12537,11 @@ var init_SchemaValidator = __esm({
         this._findSchemaDir = () => {
           let dir = __dirname;
           for (let i6 = 0; i6 < 5; i6++) {
-            const candidate = import_path3.default.join(dir, "json_schemas");
-            if (import_fs3.default.existsSync(candidate)) return candidate;
-            dir = import_path3.default.dirname(dir);
+            const candidate = import_path4.default.join(dir, "json_schemas");
+            if (import_fs4.default.existsSync(candidate)) return candidate;
+            dir = import_path4.default.dirname(dir);
           }
-          return import_path3.default.join(__dirname, "json_schemas");
+          return import_path4.default.join(__dirname, "json_schemas");
         };
         this.ajv = new import_ajv.default({
           allErrors: true,
@@ -12961,6 +13150,7 @@ var init_Validator = __esm({
               }
             }
             errors.push(...this.validateOmitNull(consumer));
+            errors.push(...this.validateHeader(consumer));
             errors.push(...this.validateSplit(consumer));
             const dimensionFields = consumer.fields.filter((x2) => x2.key !== "*" && !x2.fixed && !x2.copyFrom && !x2.lineCount);
             const dimensionKeys = dimensionFields.map((x2) => `${x2.from ?? "_default_"}::${x2.key}`);
@@ -13075,6 +13265,22 @@ var init_Validator = __esm({
           }
           return errors;
         };
+        /**
+         * Checks `header`, which writes the field names as the first line of an exported file. A JSON
+         * record carries its own field names and an API response is not a file, so the flag means
+         * nothing there — rejected rather than ignored, so a config that asks for a header always gets
+         * one.
+         */
+        this.validateHeader = (consumer) => {
+          const errors = [];
+          const positionalFormats = ["CSV", "TXT", "PARQUET"];
+          for (const output of (consumer.outputs ?? []).filter((x2) => Algo_default.hasVal(x2.header))) {
+            const format4 = output.format.toUpperCase();
+            if (!positionalFormats.includes(format4))
+              errors.push(`The ${format4} output of consumer "${consumer.name}" declares "header", which only applies to CSV/TXT output: a ${format4} record already carries its own field names.`);
+          }
+          return errors;
+        };
         /**
          * Checks a field whose key selects columns by pattern ("addr*Street"). A pattern that matches
          * nothing is always a mistake — a renamed dimension, or a producer that never had those columns —
@@ -13150,7 +13356,7 @@ var init_Validator = __esm({
          */
         this.detectOnFinishRecursion = (consumer) => {
           const errors = [];
-          const path20 = [];
+          const path22 = [];
           const targetsOf = (cons) => {
             const names = [];
             for (const output of cons.outputs ?? []) {
@@ -13162,17 +13368,17 @@ var init_Validator = __esm({
             return names;
           };
           const walk = (name) => {
-            if (path20.some((x2) => x2.toLowerCase() === name.toLowerCase())) {
-              errors.push(`Consumer "${consumer.name}" has a cyclic run-consumer (onSuccess/onError) chain: ${[...path20, name].join(" -> ")}`);
+            if (path22.some((x2) => x2.toLowerCase() === name.toLowerCase())) {
+              errors.push(`Consumer "${consumer.name}" has a cyclic run-consumer (onSuccess/onError) chain: ${[...path22, name].join(" -> ")}`);
               return true;
             }
             const cons = Environment_default.getConsumer(name);
             if (!cons) return false;
-            path20.push(name);
+            path22.push(name);
             for (const target of targetsOf(cons)) {
               if (walk(target)) return true;
             }
-            path20.pop();
+            path22.pop();
             return false;
           };
           walk(consumer.name);
@@ -13757,14 +13963,14 @@ ${errors.map((x2) => `  - ${x2}`).join("\n")}`);
 });
 
 // ../../packages/common/src/Environment.ts
-var import_fs4, import_crypto, import_adm_zip, import_path4, import_client_s3, RESOURCE_SCHEMA_KEYS, INVALID_RESOURCE_MESSAGES, STAGING_DIRECTORY, EnvironmentClass, Environment, Environment_default;
+var import_fs5, import_crypto, import_adm_zip2, import_path5, import_client_s3, RESOURCE_SCHEMA_KEYS, INVALID_RESOURCE_MESSAGES, STAGING_DIRECTORY, EnvironmentClass, Environment, Environment_default;
 var init_Environment = __esm({
   "../../packages/common/src/Environment.ts"() {
-    import_fs4 = __toESM(require("fs"), 1);
+    import_fs5 = __toESM(require("fs"), 1);
     import_crypto = __toESM(require("crypto"), 1);
-    import_adm_zip = __toESM(require("adm-zip"), 1);
+    import_adm_zip2 = __toESM(require("adm-zip"), 1);
     init_src();
-    import_path4 = __toESM(require("path"), 1);
+    import_path5 = __toESM(require("path"), 1);
     init_SchemaValidator();
     init_SchemaErrorReporter();
     init_Validator();
@@ -13886,16 +14092,16 @@ var init_Environment = __esm({
         this._saveConfigFile = (buffer, url) => {
           Affirm_default(buffer?.length, `Empty configuration archive downloaded from ${url}`);
           const zip = this._readArchive(buffer, url);
-          const extractPath = import_path4.default.join(this._localPath, "remora");
-          const stagingPath = import_path4.default.join(this._localPath, STAGING_DIRECTORY);
-          import_fs4.default.rmSync(stagingPath, { recursive: true, force: true });
+          const extractPath = import_path5.default.join(this._localPath, "remora");
+          const stagingPath = import_path5.default.join(this._localPath, STAGING_DIRECTORY);
+          import_fs5.default.rmSync(stagingPath, { recursive: true, force: true });
           try {
             zip.extractAllTo(stagingPath, true);
             this._clearConfigDirectory(extractPath);
-            for (const entry of import_fs4.default.readdirSync(stagingPath))
-              import_fs4.default.renameSync(import_path4.default.join(stagingPath, entry), import_path4.default.join(extractPath, entry));
+            for (const entry of import_fs5.default.readdirSync(stagingPath))
+              import_fs5.default.renameSync(import_path5.default.join(stagingPath, entry), import_path5.default.join(extractPath, entry));
           } finally {
-            import_fs4.default.rmSync(stagingPath, { recursive: true, force: true });
+            import_fs5.default.rmSync(stagingPath, { recursive: true, force: true });
           }
           Logger_default.log(`Remote configuration downloaded and extracted from ${url}`);
           return true;
@@ -13907,7 +14113,7 @@ var init_Environment = __esm({
          */
         this._readArchive = (buffer, url) => {
           try {
-            const zip = new import_adm_zip.default(buffer);
+            const zip = new import_adm_zip2.default(buffer);
             Affirm_default.hasItems(zip.getEntries(), `Configuration archive from ${url} contains no files`);
             return zip;
           } catch (error) {
@@ -13919,17 +14125,17 @@ var init_Environment = __esm({
         };
         /** Remove everything the previous configuration left behind, keeping the run scratch directory. */
         this._clearConfigDirectory = (extractPath) => {
-          if (!import_fs4.default.existsSync(extractPath)) {
-            import_fs4.default.mkdirSync(extractPath, { recursive: true });
+          if (!import_fs5.default.existsSync(extractPath)) {
+            import_fs5.default.mkdirSync(extractPath, { recursive: true });
             return;
           }
-          for (const file of import_fs4.default.readdirSync(extractPath)) {
+          for (const file of import_fs5.default.readdirSync(extractPath)) {
             if (file === "temp") continue;
-            const filePath = import_path4.default.join(extractPath, file);
-            if (import_fs4.default.statSync(filePath).isDirectory())
-              import_fs4.default.rmSync(filePath, { recursive: true, force: true });
+            const filePath = import_path5.default.join(extractPath, file);
+            if (import_fs5.default.statSync(filePath).isDirectory())
+              import_fs5.default.rmSync(filePath, { recursive: true, force: true });
             else
-              import_fs4.default.unlinkSync(filePath);
+              import_fs5.default.unlinkSync(filePath);
           }
         };
         /**
@@ -13988,13 +14194,13 @@ var init_Environment = __esm({
          * project's own JSON schemas means registering that schema first.
          */
         this.inspect = (remoraPath) => {
-          const envPath = import_path4.default.join(remoraPath, "remora");
+          const envPath = import_path5.default.join(remoraPath, "remora");
           const problems = [];
           const projectConfig = this._readProjectConfig(envPath, problems);
           if (!projectConfig) return this._emptyInspection(problems);
           SchemaValidator_default.unloadSchemas();
           const read = (entries) => this._readConfigs(envPath, entries, remoraPath, problems);
-          const optional = (folder) => import_fs4.default.existsSync(import_path4.default.join(envPath, folder)) ? [folder] : [];
+          const optional = (folder) => import_fs5.default.existsSync(import_path5.default.join(envPath, folder)) ? [folder] : [];
           const folders = Constants_default.RESOURCE_FOLDERS;
           const schemaFiles = read(optional(folders.schemas));
           const schemas = schemaFiles.map((x2) => x2.config);
@@ -14078,14 +14284,14 @@ var init_Environment = __esm({
          * picture for the preview.
          */
         this._readProjectConfig = (envPath, problems) => {
-          const projectPath = import_path4.default.join(envPath, "project.json");
-          if (!import_fs4.default.existsSync(projectPath)) {
+          const projectPath = import_path5.default.join(envPath, "project.json");
+          if (!import_fs5.default.existsSync(projectPath)) {
             problems.push({ severity: "error", scope: "project", file: projectPath, message: "Project configuration file not found" });
             return null;
           }
           let projectConfig;
           try {
-            projectConfig = JSON.parse(import_fs4.default.readFileSync(projectPath, "utf-8"));
+            projectConfig = JSON.parse(import_fs5.default.readFileSync(projectPath, "utf-8"));
           } catch (error) {
             problems.push({ severity: "error", scope: "project", file: projectPath, message: this._messageOf(error) });
             return null;
@@ -14132,7 +14338,7 @@ var init_Environment = __esm({
           for (const configPath of entries ?? []) {
             for (const file of this._resolveConfigFiles(envPath, configPath, remoraPath, problems)) {
               try {
-                configs.push({ config: JSON.parse(import_fs4.default.readFileSync(file, "utf-8")), file });
+                configs.push({ config: JSON.parse(import_fs5.default.readFileSync(file, "utf-8")), file });
               } catch (error) {
                 problems.push({
                   severity: "error",
@@ -14147,9 +14353,9 @@ var init_Environment = __esm({
         };
         /** The files one project.json entry resolves to: itself, or every .json under it if it is a directory. */
         this._resolveConfigFiles = (envPath, configPath, remoraPath, problems) => {
-          const fullPath = import_path4.default.join(envPath, configPath);
+          const fullPath = import_path5.default.join(envPath, configPath);
           try {
-            return import_fs4.default.statSync(fullPath).isDirectory() ? this._readJsonFilesRecursively(fullPath) : [fullPath];
+            return import_fs5.default.statSync(fullPath).isDirectory() ? this._readJsonFilesRecursively(fullPath) : [fullPath];
           } catch (error) {
             problems.push({
               severity: "error",
@@ -14162,8 +14368,8 @@ var init_Environment = __esm({
         };
         this._readJsonFilesRecursively = (dirPath) => {
           const results = [];
-          for (const entry of import_fs4.default.readdirSync(dirPath, { withFileTypes: true })) {
-            const fullEntry = import_path4.default.join(dirPath, entry.name);
+          for (const entry of import_fs5.default.readdirSync(dirPath, { withFileTypes: true })) {
+            const fullEntry = import_path5.default.join(dirPath, entry.name);
             if (entry.isDirectory())
               results.push(...this._readJsonFilesRecursively(fullEntry));
             else if (entry.name.endsWith(".json"))
@@ -14268,7 +14474,7 @@ var init_Environment = __esm({
           resourceFiles: []
         });
         /** Kept verbatim from the batch loader this replaced, so `load()` still throws the same string. */
-        this._loadFailureMessage = (remoraPath, configPath, error) => `Error loading from ${import_path4.default.resolve(remoraPath)} configuration from ${configPath}: ${this._messageOf(error)}`;
+        this._loadFailureMessage = (remoraPath, configPath, error) => `Error loading from ${import_path5.default.resolve(remoraPath)} configuration from ${configPath}: ${this._messageOf(error)}`;
         this._messageOf = (error) => error instanceof Error ? error.message : String(error);
         /**
          * The loaded environment, flattened for transport to a worker thread.
@@ -14410,14 +14616,14 @@ var init_Environment = __esm({
         this.resolveResourceFilePath = (folder, resourceName) => {
           Affirm_default(folder, "Invalid resource folder");
           Affirm_default(resourceName, "Invalid resource name");
-          const baseDir = import_path4.default.join(this._localPath || "", "remora", folder);
-          const defaultPath = import_path4.default.join(baseDir, `${resourceName}.json`);
+          const baseDir = import_path5.default.join(this._localPath || "", "remora", folder);
+          const defaultPath = import_path5.default.join(baseDir, `${resourceName}.json`);
           return this._findConfigFileByName(baseDir, resourceName) || defaultPath;
         };
         this._findConfigFileByName = (dirPath, resourceName) => {
-          if (!import_fs4.default.existsSync(dirPath)) return null;
-          for (const entry of import_fs4.default.readdirSync(dirPath, { withFileTypes: true })) {
-            const fullPath = import_path4.default.join(dirPath, entry.name);
+          if (!import_fs5.default.existsSync(dirPath)) return null;
+          for (const entry of import_fs5.default.readdirSync(dirPath, { withFileTypes: true })) {
+            const fullPath = import_path5.default.join(dirPath, entry.name);
             if (entry.isDirectory()) {
               const nested = this._findConfigFileByName(fullPath, resourceName);
               if (nested) return nested;
@@ -14425,7 +14631,7 @@ var init_Environment = __esm({
             }
             if (!entry.name.endsWith(".json")) continue;
             try {
-              const parsed = JSON.parse(import_fs4.default.readFileSync(fullPath, "utf-8"));
+              const parsed = JSON.parse(import_fs5.default.readFileSync(fullPath, "utf-8"));
               if (parsed?.name === resourceName) return fullPath;
             } catch {
             }
@@ -14490,18 +14696,18 @@ ${ce3.map((x2) => `	-${x2}
          * Same digest as the one `load()` records, so the two can never disagree about "changed".
          */
         this.configHash = (remoraPath) => {
-          const envPath = import_path4.default.join(remoraPath, "remora");
-          if (!import_fs4.default.existsSync(envPath)) return null;
+          const envPath = import_path5.default.join(remoraPath, "remora");
+          if (!import_fs5.default.existsSync(envPath)) return null;
           const hash = import_crypto.default.createHash("sha256");
           const hashDir = (dirPath) => {
-            if (!import_fs4.default.existsSync(dirPath)) return;
-            for (const entry of import_fs4.default.readdirSync(dirPath, { withFileTypes: true })) {
+            if (!import_fs5.default.existsSync(dirPath)) return;
+            for (const entry of import_fs5.default.readdirSync(dirPath, { withFileTypes: true })) {
               if (entry.name === "temp" || entry.name === ".temp") continue;
-              const fullEntry = import_path4.default.join(dirPath, entry.name);
+              const fullEntry = import_path5.default.join(dirPath, entry.name);
               if (entry.isDirectory())
                 hashDir(fullEntry);
               else if (entry.name.endsWith(".json"))
-                hash.update(import_fs4.default.readFileSync(fullEntry, "utf-8"));
+                hash.update(import_fs5.default.readFileSync(fullEntry, "utf-8"));
             }
           };
           hashDir(envPath);
@@ -14520,6 +14726,8 @@ var init_src4 = __esm({
     init_ProcessENVManager();
     init_ProcessShutdownManager();
     init_SecretManager();
+    init_SecretRedactor();
+    init_ConfigPackager();
     init_ExecutorScope();
     init_Environment();
     init_ResourcesUtils();
@@ -15285,14 +15493,14 @@ var init_readFile = __esm({
     import_promises3 = require("fs/promises");
     filePromises = {};
     fileIntercept = {};
-    readFile2 = (path20, options2) => {
-      if (fileIntercept[path20] !== void 0) {
-        return fileIntercept[path20];
+    readFile2 = (path22, options2) => {
+      if (fileIntercept[path22] !== void 0) {
+        return fileIntercept[path22];
       }
-      if (!filePromises[path20] || options2?.ignoreCache) {
-        filePromises[path20] = (0, import_promises3.readFile)(path20, "utf8");
+      if (!filePromises[path22] || options2?.ignoreCache) {
+        filePromises[path22] = (0, import_promises3.readFile)(path22, "utf8");
       }
-      return filePromises[path20];
+      return filePromises[path22];
     };
   }
 });
@@ -15404,8 +15612,8 @@ var init_externalDataInterceptor = __esm({
       getFileRecord() {
         return fileIntercept;
       },
-      interceptFile(path20, contents) {
-        fileIntercept[path20] = Promise.resolve(contents);
+      interceptFile(path22, contents) {
+        fileIntercept[path22] = Promise.resolve(contents);
       },
       getTokenRecord() {
         return tokenIntercept;
@@ -18485,8 +18693,8 @@ var init_createConfigValueProvider = __esm({
               return endpoint.url.href;
             }
             if ("hostname" in endpoint) {
-              const { protocol, hostname, port, path: path20 } = endpoint;
-              return `${protocol}//${hostname}${port ? ":" + port : ""}${path20}`;
+              const { protocol, hostname, port, path: path22 } = endpoint;
+              return `${protocol}//${hostname}${port ? ":" + port : ""}${path22}`;
             }
           }
           return endpoint;
@@ -18861,18 +19069,18 @@ var getAttrPathList;
 var init_getAttrPathList = __esm({
   "../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/getAttrPathList.js"() {
     init_types2();
-    getAttrPathList = (path20) => {
-      const parts = path20.split(".");
+    getAttrPathList = (path22) => {
+      const parts = path22.split(".");
       const pathList = [];
       for (const part of parts) {
         const squareBracketIndex = part.indexOf("[");
         if (squareBracketIndex !== -1) {
           if (part.indexOf("]") !== part.length - 1) {
-            throw new EndpointError(`Path: '${path20}' does not end with ']'`);
+            throw new EndpointError(`Path: '${path22}' does not end with ']'`);
           }
           const arrayIndex = part.slice(squareBracketIndex + 1, -1);
           if (Number.isNaN(parseInt(arrayIndex))) {
-            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path20}'`);
+            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path22}'`);
           }
           if (squareBracketIndex !== 0) {
             pathList.push(part.slice(0, squareBracketIndex));
@@ -18893,9 +19101,9 @@ var init_getAttr = __esm({
   "../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/getAttr.js"() {
     init_types2();
     init_getAttrPathList();
-    getAttr = (value, path20) => getAttrPathList(path20).reduce((acc, index) => {
+    getAttr = (value, path22) => getAttrPathList(path22).reduce((acc, index) => {
       if (typeof acc !== "object") {
-        throw new EndpointError(`Index '${index}' in '${path20}' not found in '${JSON.stringify(value)}'`);
+        throw new EndpointError(`Index '${index}' in '${path22}' not found in '${JSON.stringify(value)}'`);
       } else if (Array.isArray(acc)) {
         const i6 = parseInt(index);
         return acc[i6 < 0 ? acc.length + i6 : i6];
@@ -18956,8 +19164,8 @@ var init_parseURL = __esm({
             return value;
           }
           if (typeof value === "object" && "hostname" in value) {
-            const { hostname: hostname2, port, protocol: protocol2 = "", path: path20 = "", query = {} } = value;
-            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path20}`);
+            const { hostname: hostname2, port, protocol: protocol2 = "", path: path22 = "", query = {} } = value;
+            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path22}`);
             url.search = Object.entries(query).map(([k7, v3]) => `${k7}=${v3}`).join("&");
             return url;
           }
@@ -21301,11 +21509,11 @@ var init_HttpBindingProtocol = __esm({
           const opTraits = translateTraits(operationSchema.traits);
           if (opTraits.http) {
             request.method = opTraits.http[0];
-            const [path20, search] = opTraits.http[1].split("?");
+            const [path22, search] = opTraits.http[1].split("?");
             if (request.path == "/") {
-              request.path = path20;
+              request.path = path22;
             } else {
-              request.path += path20;
+              request.path += path22;
             }
             const traitSearchParams = new URLSearchParams(search ?? "");
             for (const [key, value] of traitSearchParams) {
@@ -25018,12 +25226,12 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             const password = request.password ?? "";
             auth = `${username}:${password}`;
           }
-          let path20 = request.path;
+          let path22 = request.path;
           if (queryString) {
-            path20 += `?${queryString}`;
+            path22 += `?${queryString}`;
           }
           if (request.fragment) {
-            path20 += `#${request.fragment}`;
+            path22 += `#${request.fragment}`;
           }
           let hostname = request.hostname ?? "";
           if (hostname[0] === "[" && hostname.endsWith("]")) {
@@ -25035,7 +25243,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             headers: request.headers,
             host: hostname,
             method: request.method,
-            path: path20,
+            path: path22,
             port: request.port,
             agent,
             auth
@@ -25944,10 +26152,10 @@ ${longDate}
 ${credentialScope}
 ${toHex(hashedRequest)}`;
       }
-      getCanonicalPath({ path: path20 }) {
+      getCanonicalPath({ path: path22 }) {
         if (this.uriEscapePath) {
           const normalizedPathSegments = [];
-          for (const pathSegment of path20.split("/")) {
+          for (const pathSegment of path22.split("/")) {
             if (pathSegment?.length === 0)
               continue;
             if (pathSegment === ".")
@@ -25958,11 +26166,11 @@ ${toHex(hashedRequest)}`;
               normalizedPathSegments.push(pathSegment);
             }
           }
-          const normalizedPath = `${path20?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path20?.endsWith("/") ? "/" : ""}`;
+          const normalizedPath = `${path22?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path22?.endsWith("/") ? "/" : ""}`;
           const doubleEncoded = escapeUri(normalizedPath);
           return doubleEncoded.replace(/%2F/g, "/");
         }
-        return path20;
+        return path22;
       }
       validateResolvedCredentials(credentials) {
         if (typeof credentials !== "object" || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string") {
@@ -33673,7 +33881,7 @@ var require_pend = __commonJS({
 // ../../node_modules/yauzl/fd-slicer.js
 var require_fd_slicer = __commonJS({
   "../../node_modules/yauzl/fd-slicer.js"(exports2) {
-    var fs28 = require("fs");
+    var fs31 = require("fs");
     var util = require("util");
     var stream = require("stream");
     var Readable10 = stream.Readable;
@@ -33693,7 +33901,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self2 = this;
       self2.pend.go(function(cb) {
-        fs28.read(self2.fd, buffer, offset, length, position, function(err2, bytesRead, buffer2) {
+        fs31.read(self2.fd, buffer, offset, length, position, function(err2, bytesRead, buffer2) {
           cb();
           callback(err2, bytesRead, buffer2);
         });
@@ -33710,7 +33918,7 @@ var require_fd_slicer = __commonJS({
       self2.refCount -= 1;
       if (self2.refCount < 0) throw new Error("invalid unref");
       if (self2.refCount > 0) return;
-      fs28.close(self2.fd, onCloseDone);
+      fs31.close(self2.fd, onCloseDone);
       function onCloseDone(err2) {
         if (err2) {
           self2.emit("error", err2);
@@ -33742,7 +33950,7 @@ var require_fd_slicer = __commonJS({
       }
       self2.context.pend.go(function(cb) {
         var buffer = Buffer.allocUnsafe(toRead);
-        fs28.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err2, bytesRead) {
+        fs31.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err2, bytesRead) {
           if (err2) {
             self2.destroy(err2);
           } else if (bytesRead === 0) {
@@ -34102,7 +34310,7 @@ var require_crc32 = __commonJS({
 // ../../node_modules/yauzl/index.js
 var require_yauzl = __commonJS({
   "../../node_modules/yauzl/index.js"(exports2) {
-    var fs28 = require("fs");
+    var fs31 = require("fs");
     var zlib3 = require("zlib");
     var fd_slicer = require_fd_slicer();
     var util = require("util");
@@ -34127,9 +34335,9 @@ var require_yauzl = __commonJS({
     exports2.Entry = Entry;
     exports2.LocalFileHeader = LocalFileHeader;
     exports2.RandomAccessReader = RandomAccessReader;
-    function openPromise(path20, options2) {
+    function openPromise(path22, options2) {
       return new Promise((resolve, reject) => {
-        open(path20, { ...options2, lazyEntries: true }, function(err2, zipfile) {
+        open(path22, { ...options2, lazyEntries: true }, function(err2, zipfile) {
           if (err2) return reject(err2);
           resolve(zipfile);
         });
@@ -34159,7 +34367,7 @@ var require_yauzl = __commonJS({
         });
       });
     }
-    function open(path20, options2, callback) {
+    function open(path22, options2, callback) {
       if (typeof options2 === "function") {
         callback = options2;
         options2 = null;
@@ -34171,10 +34379,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs28.open(path20, "r", function(err2, fd) {
+      fs31.open(path22, "r", function(err2, fd) {
         if (err2) return callback(err2);
         fromFd(fd, options2, function(err3, zipfile) {
-          if (err3) fs28.close(fd, defaultCallback);
+          if (err3) fs31.close(fd, defaultCallback);
           callback(err3, zipfile);
         });
       });
@@ -34191,7 +34399,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs28.fstat(fd, function(err2, stats) {
+      fs31.fstat(fd, function(err2, stats) {
         if (err2) return callback(err2);
         var reader = new fd_slicer.FdSlicer(fd);
         fromRandomAccessReader(reader, stats.size, options2, callback);
@@ -34969,17 +35177,17 @@ function Yn(s5, t2) {
 function Kn(s5, t2) {
   s5.head = new ue(t2, void 0, s5.head, s5), s5.tail || (s5.tail = s5.head), s5.length++;
 }
-var import_events, import_fs5, import_node_events, import_node_stream6, import_node_string_decoder, import_node_path7, import_node_fs5, import_path5, import_events2, import_assert, import_buffer, Ps, import_zlib, import_node_path8, import_node_path9, import_fs6, import_fs7, import_path6, import_node_path10, import_path7, import_node_fs6, import_node_assert, import_node_crypto5, import_node_fs7, import_node_path11, import_fs8, import_node_fs8, import_node_path12, import_node_fs9, import_promises5, import_node_path13, import_node_path14, import_node_fs10, import_node_path15, zr, Ur, Ds, Wr, Gr, Zr, Q, J, nt, De, qt, Ne, Ns, Ae, As, z2, Mt, g5, Qt, Bt, b5, N, _, bi, Ie, L, S, _i, Oi, Is, Ti, Z, xi, Ce, Jt, Rt, C, jt, Yr, Kr, Vr, $r, Fe, Li, Xr, qr, A, Jr, ht, H, te, m3, Ni, tt, Ai, ki, vi, ie, ke, Ut, Ht, Ii, Pt, at, U, ot, Y, zt, Ci, j5, ee, Fi, ve, gt, Me, bt, _t, Be, et, Wt, jr, Fs, ks, vs, Ms, Bs, tn, se, K2, sn, M, rn, zs, nn, Bi, Tt, Gt, Pi, re, Pe, ze, Ue, He, We, Ge, Ze, Ye, Ke, Us, hn, an, Hs, ln, cn, Ws, Gs, Hi, ne, dn, Ui, oe, Ve, un, F, mn, xt, Wi, pn, lt, En, wn, Sn, ct, yn, Rn, gn, Gi, bn, Lt, ft, On, Tn, xn, Ln, f5, $e, Dt, Nn, Xi, qi, An, B, Nt, it, Zi, Zs, V, he, dt, Ys, p3, st, ut, Yi, At, w, Xe, qe, Ki, Ks, Vs, ae, Vi, Qe, Yt, $, Je, It, je, ti, $s, In, le, $i, Xs, Cn, rt, mt, vn, Qi, Mn, Bn, Ct, Ji, zn, qs, ce, ei, ji, Un, Hn, ts, Qs, rr, Wn, tr, er, ir, is, sr, fe, ii, ss, si, rs, ns, os, hs, pt, ri, as, es, q3, de, ni, oi, Gn, hi, ue, pi, nr, li, me, W, pe, Et, Ft, Ee, ai, G, ls, ci, or, ds, us, fi, di, hr, cs, ui, lr, fs7, wt, kt, Vn, $n, fr, dr, Xn, qn, Qn, Jn, Er, wr, ur, Sr, yr, Rr, jn, to, eo, mr, ms, ps, Ei, io, Es, so, ws, Se, St, no, gr, Ss, br, oo, _r3, ys, Or, Vt, Tr, ho, ao, lo, yi, Lr, Dr, _s5, Nr, Os, P, Ts, xs, gi, Ar, Ir, Re, Cr, Fr, Rs, yt, O, Ri, kr, $t, gs, bs, Ls, ge, be, _e5, Oe, fo, Te, uo, mo, po, vr, Xt, ye, xe, Eo, wo, So, yo, Ro, go, bo, _o, vt, Oo, To;
+var import_events, import_fs6, import_node_events, import_node_stream6, import_node_string_decoder, import_node_path7, import_node_fs5, import_path6, import_events2, import_assert, import_buffer, Ps, import_zlib, import_node_path8, import_node_path9, import_fs7, import_fs8, import_path7, import_node_path10, import_path8, import_node_fs6, import_node_assert, import_node_crypto5, import_node_fs7, import_node_path11, import_fs9, import_node_fs8, import_node_path12, import_node_fs9, import_promises5, import_node_path13, import_node_path14, import_node_fs10, import_node_path15, zr, Ur, Ds, Wr, Gr, Zr, Q, J, nt, De, qt, Ne, Ns, Ae, As, z2, Mt, g5, Qt, Bt, b5, N, _, bi, Ie, L, S, _i, Oi, Is, Ti, Z, xi, Ce, Jt, Rt, C, jt, Yr, Kr, Vr, $r, Fe, Li, Xr, qr, A, Jr, ht, H, te, m3, Ni, tt, Ai, ki, vi, ie, ke, Ut, Ht, Ii, Pt, at, U, ot, Y, zt, Ci, j5, ee, Fi, ve, gt, Me, bt, _t, Be, et, Wt, jr, Fs, ks, vs, Ms, Bs, tn, se, K2, sn, M, rn, zs, nn, Bi, Tt, Gt, Pi, re, Pe, ze, Ue, He, We, Ge, Ze, Ye, Ke, Us, hn, an, Hs, ln, cn, Ws, Gs, Hi, ne, dn, Ui, oe, Ve, un, F, mn, xt, Wi, pn, lt, En, wn, Sn, ct, yn, Rn, gn, Gi, bn, Lt, ft, On, Tn, xn, Ln, f5, $e, Dt, Nn, Xi, qi, An, B, Nt, it, Zi, Zs, V, he, dt, Ys, p3, st, ut, Yi, At, w, Xe, qe, Ki, Ks, Vs, ae, Vi, Qe, Yt, $, Je, It, je, ti, $s, In, le, $i, Xs, Cn, rt, mt, vn, Qi, Mn, Bn, Ct, Ji, zn, qs, ce, ei, ji, Un, Hn, ts, Qs, rr, Wn, tr, er, ir, is, sr, fe, ii, ss, si, rs, ns, os, hs, pt, ri, as, es, q3, de, ni, oi, Gn, hi, ue, pi, nr, li, me, W, pe, Et, Ft, Ee, ai, G, ls, ci, or, ds, us, fi, di, hr, cs, ui, lr, fs8, wt, kt, Vn, $n, fr, dr, Xn, qn, Qn, Jn, Er, wr, ur, Sr, yr, Rr, jn, to, eo, mr, ms, ps, Ei, io, Es, so, ws, Se, St, no, gr, Ss, br, oo, _r3, ys, Or, Vt, Tr, ho, ao, lo, yi, Lr, Dr, _s5, Nr, Os, P, Ts, xs, gi, Ar, Ir, Re, Cr, Fr, Rs, yt, O, Ri, kr, $t, gs, bs, Ls, ge, be, _e5, Oe, fo, Te, uo, mo, po, vr, Xt, ye, xe, Eo, wo, So, yo, Ro, go, bo, _o, vt, Oo, To;
 var init_index_min = __esm({
   "../../packages/parsing/node_modules/tar/dist/esm/index.min.js"() {
     import_events = __toESM(require("events"), 1);
-    import_fs5 = __toESM(require("fs"), 1);
+    import_fs6 = __toESM(require("fs"), 1);
     import_node_events = require("events");
     import_node_stream6 = __toESM(require("stream"), 1);
     import_node_string_decoder = require("string_decoder");
     import_node_path7 = __toESM(require("path"), 1);
     import_node_fs5 = __toESM(require("fs"), 1);
-    import_path5 = require("path");
+    import_path6 = require("path");
     import_events2 = require("events");
     import_assert = __toESM(require("assert"), 1);
     import_buffer = require("buffer");
@@ -34987,17 +35195,17 @@ var init_index_min = __esm({
     import_zlib = __toESM(require("zlib"), 1);
     import_node_path8 = require("path");
     import_node_path9 = require("path");
-    import_fs6 = __toESM(require("fs"), 1);
     import_fs7 = __toESM(require("fs"), 1);
-    import_path6 = __toESM(require("path"), 1);
-    import_node_path10 = require("path");
+    import_fs8 = __toESM(require("fs"), 1);
     import_path7 = __toESM(require("path"), 1);
+    import_node_path10 = require("path");
+    import_path8 = __toESM(require("path"), 1);
     import_node_fs6 = __toESM(require("fs"), 1);
     import_node_assert = __toESM(require("assert"), 1);
     import_node_crypto5 = require("crypto");
     import_node_fs7 = __toESM(require("fs"), 1);
     import_node_path11 = __toESM(require("path"), 1);
-    import_fs8 = __toESM(require("fs"), 1);
+    import_fs9 = __toESM(require("fs"), 1);
     import_node_fs8 = __toESM(require("fs"), 1);
     import_node_path12 = __toESM(require("path"), 1);
     import_node_fs9 = __toESM(require("fs"), 1);
@@ -35349,7 +35557,7 @@ var init_index_min = __esm({
         return Wr;
       }
     };
-    Jr = import_fs5.default.writev;
+    Jr = import_fs6.default.writev;
     ht = /* @__PURE__ */ Symbol("_autoClose");
     H = /* @__PURE__ */ Symbol("_close");
     te = /* @__PURE__ */ Symbol("_ended");
@@ -35404,7 +35612,7 @@ var init_index_min = __esm({
         throw new TypeError("this is a readable stream");
       }
       [at]() {
-        import_fs5.default.open(this[U], "r", (t2, e7) => this[Ht](t2, e7));
+        import_fs6.default.open(this[U], "r", (t2, e7) => this[Ht](t2, e7));
       }
       [Ht](t2, e7) {
         t2 ? this[Ut](t2) : (this[m3] = e7, this.emit("open", e7), this[zt]());
@@ -35417,7 +35625,7 @@ var init_index_min = __esm({
           this[j5] = true;
           let t2 = this[vi]();
           if (t2.length === 0) return process.nextTick(() => this[Ii](null, 0, t2));
-          import_fs5.default.read(this[m3], t2, 0, t2.length, null, (e7, i6, r7) => this[Ii](e7, i6, r7));
+          import_fs6.default.read(this[m3], t2, 0, t2.length, null, (e7, i6, r7) => this[Ii](e7, i6, r7));
         }
       }
       [Ii](t2, e7, i6) {
@@ -35426,7 +35634,7 @@ var init_index_min = __esm({
       [H]() {
         if (this[ht] && typeof this[m3] == "number") {
           let t2 = this[m3];
-          this[m3] = void 0, import_fs5.default.close(t2, (e7) => e7 ? this.emit("error", e7) : this.emit("close"));
+          this[m3] = void 0, import_fs6.default.close(t2, (e7) => e7 ? this.emit("error", e7) : this.emit("close"));
         }
       }
       [Ut](t2) {
@@ -35454,7 +35662,7 @@ var init_index_min = __esm({
       [at]() {
         let t2 = true;
         try {
-          this[Ht](null, import_fs5.default.openSync(this[U], "r")), t2 = false;
+          this[Ht](null, import_fs6.default.openSync(this[U], "r")), t2 = false;
         } finally {
           t2 && this[H]();
         }
@@ -35465,7 +35673,7 @@ var init_index_min = __esm({
           if (!this[j5]) {
             this[j5] = true;
             do {
-              let e7 = this[vi](), i6 = e7.length === 0 ? 0 : import_fs5.default.readSync(this[m3], e7, 0, e7.length, null);
+              let e7 = this[vi](), i6 = e7.length === 0 ? 0 : import_fs6.default.readSync(this[m3], e7, 0, e7.length, null);
               if (!this[ki](i6, e7)) break;
             } while (true);
             this[j5] = false;
@@ -35478,7 +35686,7 @@ var init_index_min = __esm({
       [H]() {
         if (this[ht] && typeof this[m3] == "number") {
           let t2 = this[m3];
-          this[m3] = void 0, import_fs5.default.closeSync(t2), this.emit("close");
+          this[m3] = void 0, import_fs6.default.closeSync(t2), this.emit("close");
         }
       }
     };
@@ -35520,7 +35728,7 @@ var init_index_min = __esm({
         this[H](), this[gt] = true, this.emit("error", t2);
       }
       [at]() {
-        import_fs5.default.open(this[U], this[tt], this[ie], (t2, e7) => this[Ht](t2, e7));
+        import_fs6.default.open(this[U], this[tt], this[ie], (t2, e7) => this[Ht](t2, e7));
       }
       [Ht](t2, e7) {
         this[Me] && this[tt] === "r+" && t2 && t2.code === "ENOENT" ? (this[tt] = "w", this[at]()) : t2 ? this[Ut](t2) : (this[m3] = e7, this.emit("open", e7), this[gt] || this[Ai]());
@@ -35532,7 +35740,7 @@ var init_index_min = __esm({
         return typeof t2 == "string" && (t2 = Buffer.from(t2, e7)), this[te] ? (this.emit("error", new Error("write() after end()")), false) : this[m3] === void 0 || this[gt] || this[Y].length ? (this[Y].push(t2), this[ke] = true, false) : (this[gt] = true, this[ve](t2), true);
       }
       [ve](t2) {
-        import_fs5.default.write(this[m3], t2, 0, t2.length, this[ot], (e7, i6) => this[Pt](e7, i6));
+        import_fs6.default.write(this[m3], t2, 0, t2.length, this[ot], (e7, i6) => this[Pt](e7, i6));
       }
       [Pt](t2, e7) {
         t2 ? this[Ut](t2) : (this[ot] !== void 0 && typeof e7 == "number" && (this[ot] += e7), this[Y].length ? this[Ai]() : (this[gt] = false, this[te] && !this[Ni] ? (this[Ni] = true, this[H](), this.emit("finish")) : this[ke] && (this[ke] = false, this.emit("drain"))));
@@ -35548,7 +35756,7 @@ var init_index_min = __esm({
       [H]() {
         if (this[ht] && typeof this[m3] == "number") {
           let t2 = this[m3];
-          this[m3] = void 0, import_fs5.default.close(t2, (e7) => e7 ? this.emit("error", e7) : this.emit("close"));
+          this[m3] = void 0, import_fs6.default.close(t2, (e7) => e7 ? this.emit("error", e7) : this.emit("close"));
         }
       }
     };
@@ -35556,24 +35764,24 @@ var init_index_min = __esm({
       [at]() {
         let t2;
         if (this[Me] && this[tt] === "r+") try {
-          t2 = import_fs5.default.openSync(this[U], this[tt], this[ie]);
+          t2 = import_fs6.default.openSync(this[U], this[tt], this[ie]);
         } catch (e7) {
           if (e7?.code === "ENOENT") return this[tt] = "w", this[at]();
           throw e7;
         }
-        else t2 = import_fs5.default.openSync(this[U], this[tt], this[ie]);
+        else t2 = import_fs6.default.openSync(this[U], this[tt], this[ie]);
         this[Ht](null, t2);
       }
       [H]() {
         if (this[ht] && typeof this[m3] == "number") {
           let t2 = this[m3];
-          this[m3] = void 0, import_fs5.default.closeSync(t2), this.emit("close");
+          this[m3] = void 0, import_fs6.default.closeSync(t2), this.emit("close");
         }
       }
       [ve](t2) {
         let e7 = true;
         try {
-          this[Pt](null, import_fs5.default.writeSync(this[m3], t2, 0, t2.length, this[ot])), e7 = false;
+          this[Pt](null, import_fs6.default.writeSync(this[m3], t2, 0, t2.length, this[ot])), e7 = false;
         } finally {
           if (e7) try {
             this[H]();
@@ -36363,11 +36571,11 @@ var init_index_min = __esm({
     Qi = (s5, t2) => {
       let e7 = new Map(t2.map((o4) => [mt(o4), true])), i6 = s5.filter, r7 = 100, n4 = (o4, h6 = "", a6 = 0) => {
         if (a6 >= r7) return e7.set(o4, false), false;
-        let l4 = h6 || (0, import_path5.parse)(o4).root || ".", c6;
+        let l4 = h6 || (0, import_path6.parse)(o4).root || ".", c6;
         if (o4 === l4) c6 = false;
         else {
           let d6 = e7.get(o4);
-          c6 = d6 !== void 0 ? d6 : n4((0, import_path5.dirname)(o4), l4, a6 + 1);
+          c6 = d6 !== void 0 ? d6 : n4((0, import_path6.dirname)(o4), l4, a6 + 1);
         }
         return e7.set(o4, c6), c6;
       };
@@ -36487,7 +36695,7 @@ var init_index_min = __esm({
           let [o4, h6] = ce(this.path);
           o4 && typeof h6 == "string" && (this.path = h6, r7 = o4);
         }
-        this.win32 = !!i6.win32 || process.platform === "win32", this.win32 && (this.path = Qs(this.path.replaceAll(/\\/g, "/")), t2 = t2.replaceAll(/\\/g, "/")), this.absolute = f5(i6.absolute || import_path6.default.resolve(this.cwd, t2)), this.path === "" && (this.path = "./"), r7 && this.warn("TAR_ENTRY_INFO", `stripping ${r7} from absolute path`, { entry: this, path: r7 + this.path });
+        this.win32 = !!i6.win32 || process.platform === "win32", this.win32 && (this.path = Qs(this.path.replaceAll(/\\/g, "/")), t2 = t2.replaceAll(/\\/g, "/")), this.absolute = f5(i6.absolute || import_path7.default.resolve(this.cwd, t2)), this.path === "" && (this.path = "./"), r7 && this.warn("TAR_ENTRY_INFO", `stripping ${r7} from absolute path`, { entry: this, path: r7 + this.path });
         let n4 = this.statCache.get(this.absolute);
         n4 ? this[si](n4) : this[ss]();
       }
@@ -36498,7 +36706,7 @@ var init_index_min = __esm({
         return t2 === "error" && (this.#t = true), super.emit(t2, ...e7);
       }
       [ss]() {
-        import_fs7.default.lstat(this.absolute, (t2, e7) => {
+        import_fs8.default.lstat(this.absolute, (t2, e7) => {
           if (t2) return this.emit("error", t2);
           this[si](e7);
         });
@@ -36536,7 +36744,7 @@ var init_index_min = __esm({
         this.path.slice(-1) !== "/" && (this.path += "/"), this.stat.size = 0, this[fe](), this.end();
       }
       [is]() {
-        import_fs7.default.readlink(this.absolute, (t2, e7) => {
+        import_fs8.default.readlink(this.absolute, (t2, e7) => {
           if (t2) return this.emit("error", t2);
           this[ns](e7);
         });
@@ -36546,7 +36754,7 @@ var init_index_min = __esm({
       }
       [sr](t2) {
         if (!this.stat) throw new Error("cannot create link entry without stat");
-        this.type = "Link", this.linkpath = f5(import_path6.default.relative(this.cwd, t2)), this.stat.size = 0, this[fe](), this.end();
+        this.type = "Link", this.linkpath = f5(import_path7.default.relative(this.cwd, t2)), this.stat.size = 0, this[fe](), this.end();
       }
       [er]() {
         if (!this.stat) throw new Error("cannot create file entry without stat");
@@ -36559,7 +36767,7 @@ var init_index_min = __esm({
         this[os]();
       }
       [os]() {
-        import_fs7.default.open(this.absolute, "r", (t2, e7) => {
+        import_fs8.default.open(this.absolute, "r", (t2, e7) => {
           if (t2) return this.emit("error", t2);
           this[hs](e7);
         });
@@ -36574,14 +36782,14 @@ var init_index_min = __esm({
       [ii]() {
         let { fd: t2, buf: e7, offset: i6, length: r7, pos: n4 } = this;
         if (t2 === void 0 || e7 === void 0) throw new Error("cannot read file without first opening");
-        import_fs7.default.read(t2, e7, i6, r7, n4, (o4, h6) => {
+        import_fs8.default.read(t2, e7, i6, r7, n4, (o4, h6) => {
           if (o4) return this[pt](() => this.emit("error", o4));
           this[rs](h6);
         });
       }
       [pt](t2 = () => {
       }) {
-        this.fd !== void 0 && import_fs7.default.close(this.fd, t2);
+        this.fd !== void 0 && import_fs8.default.close(this.fd, t2);
       }
       [rs](t2) {
         if (t2 <= 0 && this.remain > 0) {
@@ -36616,20 +36824,20 @@ var init_index_min = __esm({
     ni = class extends de {
       sync = true;
       [ss]() {
-        this[si](import_fs7.default.lstatSync(this.absolute));
+        this[si](import_fs8.default.lstatSync(this.absolute));
       }
       [is]() {
-        this[ns](import_fs7.default.readlinkSync(this.absolute));
+        this[ns](import_fs8.default.readlinkSync(this.absolute));
       }
       [os]() {
-        this[hs](import_fs7.default.openSync(this.absolute, "r"));
+        this[hs](import_fs8.default.openSync(this.absolute, "r"));
       }
       [ii]() {
         let t2 = true;
         try {
           let { fd: e7, buf: i6, offset: r7, length: n4, pos: o4 } = this;
           if (e7 === void 0 || i6 === void 0) throw new Error("fd and buf must be set in READ method");
-          let h6 = import_fs7.default.readSync(e7, i6, r7, n4, o4);
+          let h6 = import_fs8.default.readSync(e7, i6, r7, n4, o4);
           this[rs](h6), t2 = false;
         } finally {
           if (t2) try {
@@ -36644,7 +36852,7 @@ var init_index_min = __esm({
       }
       [pt](t2 = () => {
       }) {
-        this.fd !== void 0 && import_fs7.default.closeSync(this.fd), t2();
+        this.fd !== void 0 && import_fs8.default.closeSync(this.fd), t2();
       }
     };
     oi = class extends A {
@@ -36898,7 +37106,7 @@ var init_index_min = __esm({
     cs = /* @__PURE__ */ Symbol("entryOpt");
     ui = /* @__PURE__ */ Symbol("writeEntryClass");
     lr = /* @__PURE__ */ Symbol("write");
-    fs7 = /* @__PURE__ */ Symbol("ondrain");
+    fs8 = /* @__PURE__ */ Symbol("ondrain");
     wt = class extends A {
       sync = false;
       opt;
@@ -36932,8 +37140,8 @@ var init_index_min = __esm({
           if ((t2.gzip ? 1 : 0) + (t2.brotli ? 1 : 0) + (t2.zstd ? 1 : 0) > 1) throw new TypeError("gzip, brotli, zstd are mutually exclusive");
           if (t2.gzip && (typeof t2.gzip != "object" && (t2.gzip = {}), this.portable && (t2.gzip.portable = true), this.zip = new ze(t2.gzip)), t2.brotli && (typeof t2.brotli != "object" && (t2.brotli = {}), this.zip = new We(t2.brotli)), t2.zstd && (typeof t2.zstd != "object" && (t2.zstd = {}), this.zip = new Ye(t2.zstd)), !this.zip) throw new Error("impossible");
           let e7 = this.zip;
-          e7.on("data", (i6) => super.write(i6)), e7.on("end", () => super.end()), e7.on("drain", () => this[fs7]()), this.on("resume", () => e7.resume());
-        } else this.on("drain", this[fs7]);
+          e7.on("data", (i6) => super.write(i6)), e7.on("end", () => super.end()), e7.on("drain", () => this[fs8]()), this.on("resume", () => e7.resume());
+        } else this.on("drain", this[fs8]);
         this.noDirRecurse = !!t2.noDirRecurse, this.follow = !!t2.follow, this.noMtime = !!t2.noMtime, t2.mtime && (this.mtime = t2.mtime), this.filter = typeof t2.filter == "function" ? t2.filter : () => true, this[W] = new hi(), this[G] = 0, this.jobs = Number(t2.jobs) || 4, this[Ee] = false, this[me] = false;
       }
       [lr](t2) {
@@ -36950,7 +37158,7 @@ var init_index_min = __esm({
         return typeof t2 == "string" ? this[ci](t2) : this[or](t2), this.flowing;
       }
       [or](t2) {
-        let e7 = f5(import_path7.default.resolve(this.cwd, t2.path));
+        let e7 = f5(import_path8.default.resolve(this.cwd, t2.path));
         if (!this.filter(t2.path, t2)) t2.resume();
         else {
           let i6 = new pi(t2.path, e7);
@@ -36959,13 +37167,13 @@ var init_index_min = __esm({
         this[Ft]();
       }
       [ci](t2) {
-        let e7 = f5(import_path7.default.resolve(this.cwd, t2));
+        let e7 = f5(import_path8.default.resolve(this.cwd, t2));
         this[W].push(new pi(t2, e7)), this[Ft]();
       }
       [ds](t2) {
         t2.pending = true, this[G] += 1;
         let e7 = this.follow ? "stat" : "lstat";
-        import_fs6.default[e7](t2.absolute, (i6, r7) => {
+        import_fs7.default[e7](t2.absolute, (i6, r7) => {
           t2.pending = false, this[G] -= 1, i6 ? this.emit("error", i6) : this[li](t2, r7);
         });
       }
@@ -36979,7 +37187,7 @@ var init_index_min = __esm({
         this[Ft]();
       }
       [us](t2) {
-        t2.pending = true, this[G] += 1, import_fs6.default.readdir(t2.absolute, (e7, i6) => {
+        t2.pending = true, this[G] += 1, import_fs7.default.readdir(t2.absolute, (e7, i6) => {
           if (t2.pending = false, this[G] -= 1, e7) return this.emit("error", e7);
           this[fi](t2, i6);
         });
@@ -37046,7 +37254,7 @@ var init_index_min = __esm({
           this.emit("error", e7);
         }
       }
-      [fs7]() {
+      [fs8]() {
         this[Et] && this[Et].entry && this[Et].entry.resume();
       }
       [di](t2) {
@@ -37080,10 +37288,10 @@ var init_index_min = __esm({
       }
       [ds](t2) {
         let e7 = this.follow ? "statSync" : "lstatSync";
-        this[li](t2, import_fs6.default[e7](t2.absolute));
+        this[li](t2, import_fs7.default[e7](t2.absolute));
       }
       [us](t2) {
-        this[fi](t2, import_fs6.default.readdirSync(t2.absolute));
+        this[fi](t2, import_fs7.default.readdirSync(t2.absolute));
       }
       [di](t2) {
         let e7 = t2.entry, i6 = this.zip;
@@ -37134,8 +37342,8 @@ var init_index_min = __esm({
     });
     Jn = process.env.__FAKE_PLATFORM__ || process.platform;
     Er = Jn === "win32";
-    ({ O_CREAT: wr, O_NOFOLLOW: ur, O_TRUNC: Sr, O_WRONLY: yr } = import_fs8.default.constants);
-    Rr = Number(process.env.__FAKE_FS_O_FILENAME__) || import_fs8.default.constants.UV_FS_O_FILEMAP || 0;
+    ({ O_CREAT: wr, O_NOFOLLOW: ur, O_TRUNC: Sr, O_WRONLY: yr } = import_fs9.default.constants);
+    Rr = Number(process.env.__FAKE_FS_O_FILENAME__) || import_fs9.default.constants.UV_FS_O_FILEMAP || 0;
     jn = Er && !!Rr;
     to = 512 * 1024;
     eo = Rr | Sr | wr | yr;
@@ -37933,12 +38141,12 @@ var init_index_min = __esm({
 });
 
 // ../../packages/parsing/src/ParseCompression.ts
-var fs8, import_zlib2, import_path8, import_yauzl, import_promises6, SUPPORTED_FORMATS, FORMAT_SIGNATURES, TRUNCATED_INPUT_CODE, ParseCompressionClass, ParseCompression, ParseCompression_default;
+var fs9, import_zlib2, import_path9, import_yauzl, import_promises6, SUPPORTED_FORMATS, FORMAT_SIGNATURES, TRUNCATED_INPUT_CODE, ParseCompressionClass, ParseCompression, ParseCompression_default;
 var init_ParseCompression = __esm({
   "../../packages/parsing/src/ParseCompression.ts"() {
-    fs8 = __toESM(require("fs"), 1);
+    fs9 = __toESM(require("fs"), 1);
     import_zlib2 = __toESM(require("zlib"), 1);
-    import_path8 = __toESM(require("path"), 1);
+    import_path9 = __toESM(require("path"), 1);
     import_yauzl = __toESM(require_yauzl(), 1);
     init_index_min();
     import_promises6 = require("stream/promises");
@@ -37968,7 +38176,7 @@ var init_ParseCompression = __esm({
           Affirm_default(fileKey, "Missing required parameter fileKey");
           Affirm_default(standardPath, "Missing required parameter standardPath");
           Affirm_default(executionPath, "Missing required parameter executionPath");
-          const archivePath = import_path8.default.join(standardPath, fileKey);
+          const archivePath = import_path9.default.join(standardPath, fileKey);
           const format4 = compressionType?.toUpperCase();
           if (!format4) {
             if ([".zip", ".tar", ".gz"].some((extension) => fileKey.includes(extension)))
@@ -37986,7 +38194,7 @@ var init_ParseCompression = __esm({
                 return await this._extractTar(archivePath, this._prepareTargetDir(executionPath));
               // GZ, the only format the affirm above leaves
               default: {
-                fs8.mkdirSync(import_path8.default.dirname(executionPath), { recursive: true });
+                fs9.mkdirSync(import_path9.default.dirname(executionPath), { recursive: true });
                 await this._gunzipFile(archivePath, executionPath);
                 return [executionPath];
               }
@@ -38005,8 +38213,8 @@ var init_ParseCompression = __esm({
          * since a file being written into one exists at zero bytes before it holds anything.
          */
         this._affirmArchive = (archivePath, format4) => {
-          Affirm_default(fs8.existsSync(archivePath), `Source file does not exist: ${archivePath}`);
-          const { size } = fs8.statSync(archivePath);
+          Affirm_default(fs9.existsSync(archivePath), `Source file does not exist: ${archivePath}`);
+          const { size } = fs9.statSync(archivePath);
           Affirm_default(size > 0, `Source file "${archivePath}" is empty (0 bytes), so there is no ${format4} archive in it to read. A file still being written into the source folder looks exactly like this \u2014 have the writer stage it under a temporary name and rename it into place, which is atomic, so a run never sees a partial file`);
           const signature = FORMAT_SIGNATURES[format4];
           if (!signature) return;
@@ -38015,11 +38223,11 @@ var init_ParseCompression = __esm({
         /** Whether a file's first bytes are exactly `expected`. Reads only those bytes, never the file. */
         this._startsWith = (filePath, expected) => {
           const head = Buffer.alloc(expected.length);
-          const handle = fs8.openSync(filePath, "r");
+          const handle = fs9.openSync(filePath, "r");
           try {
-            fs8.readSync(handle, head, 0, head.length, 0);
+            fs9.readSync(handle, head, 0, head.length, 0);
           } finally {
-            fs8.closeSync(handle);
+            fs9.closeSync(handle);
           }
           return head.equals(Buffer.from(expected));
         };
@@ -38049,9 +38257,9 @@ var init_ParseCompression = __esm({
         // same dataset path as an empty file (which is what a single-stream GZ wants). Clear that
         // placeholder — never a directory, so nothing extracted can be lost — and claim the name.
         this._prepareTargetDir = (targetDir) => {
-          if (fs8.existsSync(targetDir) && fs8.statSync(targetDir).isFile())
-            fs8.unlinkSync(targetDir);
-          fs8.mkdirSync(targetDir, { recursive: true });
+          if (fs9.existsSync(targetDir) && fs9.statSync(targetDir).isFile())
+            fs9.unlinkSync(targetDir);
+          fs9.mkdirSync(targetDir, { recursive: true });
           return targetDir;
         };
         // Extract a ZIP into targetDir one entry at a time, each entry piped from the archive straight to
@@ -38066,9 +38274,9 @@ var init_ParseCompression = __esm({
             if (entry.fileName.endsWith("/")) continue;
             Affirm_default(!entry.isEncrypted(), `Encrypted zip entry cannot be read: ${entry.fileName} in ${archivePath}`);
             const entryPath = this._resolveEntryPath(targetDir, entry.fileName);
-            fs8.mkdirSync(import_path8.default.dirname(entryPath), { recursive: true });
+            fs9.mkdirSync(import_path9.default.dirname(entryPath), { recursive: true });
             const entryStream = await zip.openReadStreamPromise(entry);
-            await (0, import_promises6.pipeline)(entryStream, fs8.createWriteStream(entryPath));
+            await (0, import_promises6.pipeline)(entryStream, fs9.createWriteStream(entryPath));
             extractedPaths.push(entryPath);
           }
           Affirm_default.hasItems(extractedPaths, `Archive ${archivePath} holds no file to read`);
@@ -38084,7 +38292,7 @@ var init_ParseCompression = __esm({
             cwd: targetDir,
             onReadEntry: (entry) => {
               if (!["File", "OldFile", "ContiguousFile"].includes(entry.type)) return;
-              extractedPaths.push(import_path8.default.resolve(targetDir, entry.path));
+              extractedPaths.push(import_path9.default.resolve(targetDir, entry.path));
             }
           });
           const maxEntries = Constants_default.defaults.MAX_ARCHIVE_ENTRIES;
@@ -38093,17 +38301,17 @@ var init_ParseCompression = __esm({
           return extractedPaths;
         };
         this._gunzipFile = async (archivePath, targetPath) => {
-          const fileContents = fs8.createReadStream(archivePath);
+          const fileContents = fs9.createReadStream(archivePath);
           const unzip = import_zlib2.default.createGunzip();
-          const writeStream = fs8.createWriteStream(targetPath);
+          const writeStream = fs9.createWriteStream(targetPath);
           await (0, import_promises6.pipeline)(fileContents, unzip, writeStream);
         };
         // Where an archive entry lands, refusing any name that escapes targetDir ('../', an absolute
         // path, a symlink-shaped name). Resolving first and comparing after is what makes '..' visible.
         this._resolveEntryPath = (targetDir, entryName) => {
-          const resolvedTarget = import_path8.default.resolve(targetDir);
-          const entryPath = import_path8.default.resolve(resolvedTarget, entryName);
-          Affirm_default(entryPath.startsWith(resolvedTarget + import_path8.default.sep), `Blocked path traversal in archive entry: ${entryName}`);
+          const resolvedTarget = import_path9.default.resolve(targetDir);
+          const entryPath = import_path9.default.resolve(resolvedTarget, entryName);
+          Affirm_default(entryPath.startsWith(resolvedTarget + import_path9.default.sep), `Blocked path traversal in archive entry: ${entryName}`);
           return entryPath;
         };
       }
@@ -38400,7 +38608,7 @@ var init_Settings = __esm({
 });
 
 // ../../packages/helper/src/Runtime.ts
-var import_node_v8, RuntimeClass, Runtime;
+var import_node_v8, RuntimeClass, Runtime, Runtime_default;
 var init_Runtime = __esm({
   "../../packages/helper/src/Runtime.ts"() {
     import_node_v8 = __toESM(require("v8"), 1);
@@ -38420,6 +38628,7 @@ var init_Runtime = __esm({
       }
     };
     Runtime = new RuntimeClass();
+    Runtime_default = Runtime;
   }
 });
 
@@ -38469,8 +38678,8 @@ var init_HttpClient = __esm({
             throw new Error(err2.message ?? "An error occurred on GET.");
           }
         };
-        this.getWorkerUrl = (path20) => {
-          const cleanPath = path20.startsWith("/") ? path20.substring(1) : path20;
+        this.getWorkerUrl = (path22) => {
+          const cleanPath = path22.startsWith("/") ? path22.substring(1) : path22;
           return `${this.workerHost}/${cleanPath}`;
         };
         this.workerHost = ProcessENVManager_default.getEnvVariable("REMORA_WORKER_HOST") || "http://worker:5069";
@@ -43978,10 +44187,10 @@ var init_src7 = __esm({
 });
 
 // ../../packages/drivers/src/DeltaShareDriver.ts
-var fs9, import_promises7, import_stream, import_promises8, MAX_LIMIT_HINT, PARQUET_BATCH_ROWS, MAX_METADATA_LOG_CHARS, DeltaShareSourceDriver, DeltaShareDriver_default;
+var fs10, import_promises7, import_stream, import_promises8, MAX_LIMIT_HINT, PARQUET_BATCH_ROWS, MAX_METADATA_LOG_CHARS, DeltaShareSourceDriver, DeltaShareDriver_default;
 var init_DeltaShareDriver = __esm({
   "../../packages/drivers/src/DeltaShareDriver.ts"() {
-    fs9 = __toESM(require("fs"), 1);
+    fs10 = __toESM(require("fs"), 1);
     import_promises7 = __toESM(require("fs/promises"), 1);
     import_stream = require("stream");
     import_promises8 = require("stream/promises");
@@ -44336,7 +44545,7 @@ var init_DeltaShareDriver = __esm({
           if (!res.ok)
             throw new Error(`Error downloading parquet from the delta share: ${res.status} ${res.statusText} (${this._redactUrl(deltaFile.file.url)})`);
           Affirm_default(res.body, `Empty response body downloading parquet from ${this._redactUrl(deltaFile.file.url)}`);
-          await (0, import_promises8.pipeline)(import_stream.Readable.fromWeb(res.body), fs9.createWriteStream(localPath));
+          await (0, import_promises8.pipeline)(import_stream.Readable.fromWeb(res.body), fs10.createWriteStream(localPath));
           const { size } = await import_promises7.default.stat(localPath);
           Logger_default.log(`Delta Share staged ${this._redactUrl(deltaFile.file.url)} (${size} bytes) in ${Date.now() - startedMs}ms`);
         };
@@ -44361,7 +44570,7 @@ var init_DeltaShareDriver = __esm({
          * disagree on their columns still produces a rectangular dataset.
          */
         this._writeDatasetFile = async (localPath, batches, delimiter) => {
-          const writer = new BatchWriter_default(fs9.createWriteStream(localPath));
+          const writer = new BatchWriter_default(fs10.createWriteStream(localPath));
           let header = null;
           let records = 0;
           try {
@@ -44468,7 +44677,7 @@ var init_DeltaShareDriver = __esm({
             ExecutorScope_default.ensurePath(localPath);
             const written = await this._stageDeltaFile(deltaFile, localPath, delimiter);
             if (written > 0) {
-              files.push({ fullUri: localPath, fileSize: fs9.statSync(localPath).size });
+              files.push({ fullUri: localPath, fileSize: fs10.statSync(localPath).size });
               records += written;
             } else {
               skipped++;
@@ -44541,10 +44750,10 @@ var init_DeltaShareDriver = __esm({
 });
 
 // ../../packages/drivers/src/sql/SqlDatasetWriter.ts
-var import_fs9, SqlDatasetWriterClass, SqlDatasetWriter, SqlDatasetWriter_default;
+var import_fs10, SqlDatasetWriterClass, SqlDatasetWriter, SqlDatasetWriter_default;
 var init_SqlDatasetWriter = __esm({
   "../../packages/drivers/src/sql/SqlDatasetWriter.ts"() {
-    import_fs9 = __toESM(require("fs"), 1);
+    import_fs10 = __toESM(require("fs"), 1);
     init_src();
     init_src5();
     SqlDatasetWriterClass = class {
@@ -44560,7 +44769,7 @@ var init_SqlDatasetWriter = __esm({
           Affirm_default(localPath, "Invalid dataset path");
           Affirm_default.hasItems(columns, "Invalid dataset columns");
           Affirm_default(batches, "Invalid dataset batches");
-          const writer = new BatchWriter_default(import_fs9.default.createWriteStream(localPath));
+          const writer = new BatchWriter_default(import_fs10.default.createWriteStream(localPath));
           let rows = 0;
           try {
             if (!writer.write(CSVParser_default.stringifyRow(columns, delimiter)))
@@ -45007,10 +45216,10 @@ var init_SqlPushdown = __esm({
 });
 
 // ../../packages/drivers/src/RedshiftDriver.ts
-var import_fs10, import_client_redshift_data, RedshiftDriver, RedshiftDriver_default;
+var import_fs11, import_client_redshift_data, RedshiftDriver, RedshiftDriver_default;
 var init_RedshiftDriver = __esm({
   "../../packages/drivers/src/RedshiftDriver.ts"() {
-    import_fs10 = __toESM(require("fs"), 1);
+    import_fs11 = __toESM(require("fs"), 1);
     import_client_redshift_data = require("@aws-sdk/client-redshift-data");
     init_src();
     init_src();
@@ -45086,7 +45295,7 @@ var init_RedshiftDriver = __esm({
           const statement = await this.waitForStatement(queryId);
           const rows = await SqlDatasetWriter_default.write(localPath, columns, this.streamResultPages(queryId), producer.settings.delimiter ?? ",");
           onProgress?.(1);
-          const fileSize = import_fs10.default.statSync(localPath).size;
+          const fileSize = import_fs11.default.statSync(localPath).size;
           const reported = statement.ResultRows >= 0 ? statement.ResultRows : null;
           Affirm_default(reported === null || reported === rows, `Redshift ready: staged ${rows} row(s) for producer "${producer.name}" but the statement reported ${reported}`);
           Logger_default.log(`Redshift ready: staged ${rows} row(s) (${fileSize} bytes) for producer "${producer.name}" from table "${table}"`);
@@ -45294,10 +45503,10 @@ var init_RedshiftDriver = __esm({
 });
 
 // ../../packages/drivers/src/sql/PostgresDriver.ts
-var import_fs11, import_crypto3, PostgresDriver, PostgresDriver_default;
+var import_fs12, import_crypto3, PostgresDriver, PostgresDriver_default;
 var init_PostgresDriver = __esm({
   "../../packages/drivers/src/sql/PostgresDriver.ts"() {
-    import_fs11 = __toESM(require("fs"), 1);
+    import_fs12 = __toESM(require("fs"), 1);
     import_crypto3 = require("crypto");
     init_src();
     init_src4();
@@ -45350,7 +45559,7 @@ var init_PostgresDriver = __esm({
             });
           }
           onProgress?.(1);
-          const fileSize = import_fs11.default.statSync(localPath).size;
+          const fileSize = import_fs12.default.statSync(localPath).size;
           Logger_default.log(`Postgres ready: staged ${rows} row(s) (${fileSize} bytes) for producer "${producer.name}" from table "${table}"`);
           return { files: [{ fullUri: localPath, fileSize }], filteredAtSource: !!pushdown.where };
         };
@@ -45710,12 +45919,12 @@ var init_HttpApiDriver = __esm({
 });
 
 // ../../packages/drivers/src/DriverHelper.ts
-var import_stream2, import_promises9, import_fs12, DriverHelper, DriverHelper_default;
+var import_stream2, import_promises9, import_fs13, DriverHelper, DriverHelper_default;
 var init_DriverHelper = __esm({
   "../../packages/drivers/src/DriverHelper.ts"() {
     import_stream2 = require("stream");
     import_promises9 = require("stream/promises");
-    import_fs12 = require("fs");
+    import_fs13 = require("fs");
     init_src2();
     init_src();
     DriverHelper = {
@@ -45806,7 +46015,7 @@ var init_DriverHelper = __esm({
           return processedLine;
         };
         const writeOptions = append ? { flags: "a" } : {};
-        const writeStream = (0, import_fs12.createWriteStream)(destinationPath, writeOptions);
+        const writeStream = (0, import_fs13.createWriteStream)(destinationPath, writeOptions);
         await (0, import_promises9.pipeline)(stream, headerValidationTransform, writeStream);
         return lineCount;
       },
@@ -45814,7 +46023,7 @@ var init_DriverHelper = __esm({
         Affirm_default(options2, "Invalid options");
         const { append, destinationPath, objects, delimiter } = options2;
         const writeOptions = append ? { flags: "a" } : {};
-        const writer = new BatchWriter_default((0, import_fs12.createWriteStream)(destinationPath, writeOptions));
+        const writer = new BatchWriter_default((0, import_fs13.createWriteStream)(destinationPath, writeOptions));
         let lineCount = 0;
         const keys = Object.keys(objects[0]);
         for (const obj of objects) {
@@ -45825,8 +46034,21 @@ var init_DriverHelper = __esm({
         await writer.close();
         return lineCount;
       },
+      /**
+       * Copies a file behind a header line, as bytes rather than lines: the header goes out first and
+       * the file is piped in behind it. Used by the destination drivers that export a dataset whose
+       * records need no transforming, so adding a header costs a copy and not a parse per record.
+       */
+      copyWithHeader: async (fromPath, toPath, header) => {
+        Affirm_default(fromPath, "Invalid source path");
+        Affirm_default(toPath, "Invalid destination path");
+        Affirm_default(header, "Invalid header line");
+        const writeStream = (0, import_fs13.createWriteStream)(toPath);
+        writeStream.write(header + "\n");
+        await (0, import_promises9.pipeline)((0, import_fs13.createReadStream)(fromPath), writeStream);
+      },
       quickReadFile: async (filePath, lineCount) => {
-        const fileStream = (0, import_fs12.createReadStream)(filePath);
+        const fileStream = (0, import_fs13.createReadStream)(filePath);
         const lines = [];
         let counter = 0;
         for await (const line of readLines(fileStream)) {
@@ -45856,11 +46078,11 @@ var init_DriverHelper = __esm({
 });
 
 // ../../packages/drivers/src/files/LocalSourceDriver.ts
-var fs13, import_path9, XLSX2, LocalSourceDriver;
+var fs14, import_path10, XLSX2, LocalSourceDriver;
 var init_LocalSourceDriver = __esm({
   "../../packages/drivers/src/files/LocalSourceDriver.ts"() {
-    fs13 = __toESM(require("fs"), 1);
-    import_path9 = __toESM(require("path"), 1);
+    fs14 = __toESM(require("fs"), 1);
+    import_path10 = __toESM(require("path"), 1);
     init_src();
     init_src();
     XLSX2 = __toESM(require("@e965/xlsx"), 1);
@@ -45876,7 +46098,7 @@ var init_LocalSourceDriver = __esm({
         this.init = async (source) => {
           const fileURL = source.authentication["path"];
           Affirm_default(fileURL, `Missing file path in the authentication of source "${source.name}"`);
-          const exist = fs13.existsSync(fileURL);
+          const exist = fs14.existsSync(fileURL);
           Affirm_default(exist, `The path (${fileURL}) for source "${source.name}" does NOT exist.`);
           this._path = source.authentication["path"];
           return this;
@@ -45890,7 +46112,7 @@ var init_LocalSourceDriver = __esm({
           if (fileKey.includes("%")) {
             const allFileKeys = this.listFiles(fileKey);
             Logger_default.log(`Matched ${allFileKeys.length} files, copying to locally and creating unified dataset.`);
-            const firstPath = import_path9.default.join(this._path, allFileKeys[0]);
+            const firstPath = import_path10.default.join(this._path, allFileKeys[0]);
             const headerLine = (await DriverHelper_default.quickReadFile(firstPath, 1))[0];
             const promises2 = allFileKeys.map((x2, i6) => this._get({ ...request, fileKey: x2 }, headerLine, i6));
             const results = await Promise.all(promises2);
@@ -45911,7 +46133,7 @@ var init_LocalSourceDriver = __esm({
           if (fileKey.includes("%")) {
             const allFileKeys = this.listFiles(fileKey);
             Logger_default.log(`Matched ${allFileKeys.length} files, copying to locally and creating unified dataset.`);
-            const firstPath = import_path9.default.join(this._path, allFileKeys[0]);
+            const firstPath = import_path10.default.join(this._path, allFileKeys[0]);
             const headerLine = (await DriverHelper_default.quickReadFile(firstPath, 1))[0];
             const promises2 = allFileKeys.map((x2, i6) => this._get({ ...request, fileKey: x2 }, headerLine, i6));
             const results = await Promise.all(promises2);
@@ -45929,12 +46151,12 @@ var init_LocalSourceDriver = __esm({
             const allFileKeys = this.listFiles(fileKey);
             return allFileKeys.length > 0;
           } else {
-            const fileUrl = import_path9.default.join(this._path, fileKey);
-            return fs13.existsSync(fileUrl);
+            const fileUrl = import_path10.default.join(this._path, fileKey);
+            return fs14.existsSync(fileUrl);
           }
         };
         this._readLines = async (fileUri, lineFrom, lineTo) => {
-          const stream = fs13.createReadStream(fileUri);
+          const stream = fs14.createReadStream(fileUri);
           const lines = [];
           let lineCounter = 0;
           for await (const line of readLines(stream)) {
@@ -45976,7 +46198,7 @@ var init_LocalSourceDriver = __esm({
             return lines;
         };
         this._readXmlLines = async (fileUri, lineFrom, lineTo) => {
-          const fileContent = fs13.readFileSync(fileUri, "utf-8");
+          const fileContent = fs14.readFileSync(fileUri, "utf-8");
           const jsonData = XMLParser_default.xmlToJson(fileContent);
           let lines = Array.isArray(jsonData) ? jsonData.map((item) => JSON.stringify(item)) : [JSON.stringify(jsonData)];
           if (Algo_default.hasVal(lineFrom) && Algo_default.hasVal(lineTo)) {
@@ -45995,7 +46217,7 @@ var init_LocalSourceDriver = __esm({
             startRow = options2.startRow;
             startColumn = options2.startColumn;
           }
-          const fileUrl = import_path9.default.join(this._path, fileKey);
+          const fileUrl = import_path10.default.join(this._path, fileKey);
           let lines = [];
           switch (fileType) {
             case "CSV":
@@ -46040,11 +46262,11 @@ var init_LocalSourceDriver = __esm({
           try {
             const getAllFiles = (dirPath, basePath = "") => {
               const files = [];
-              const items = fs13.readdirSync(dirPath);
+              const items = fs14.readdirSync(dirPath);
               for (const item of items) {
-                const fullPath = import_path9.default.join(dirPath, item);
-                const relativePath = basePath ? import_path9.default.join(basePath, item) : item;
-                const stats = fs13.statSync(fullPath);
+                const fullPath = import_path10.default.join(dirPath, item);
+                const relativePath = basePath ? import_path10.default.join(basePath, item) : item;
+                const stats = fs14.statSync(fullPath);
                 if (stats.isDirectory()) {
                   files.push(...getAllFiles(fullPath, relativePath));
                 } else if (stats.isFile()) {
@@ -46062,16 +46284,16 @@ var init_LocalSourceDriver = __esm({
         this.readFile = (fileKey) => {
           Affirm_default(this._path, "Path not initialized");
           Affirm_default(fileKey, "Invalid file key");
-          const filePath = import_path9.default.join(this._path, fileKey);
-          Affirm_default(fs13.existsSync(filePath), `Source file does not exist: ${filePath}`);
-          return fs13.readFileSync(filePath);
+          const filePath = import_path10.default.join(this._path, fileKey);
+          Affirm_default(fs14.existsSync(filePath), `Source file does not exist: ${filePath}`);
+          return fs14.readFileSync(filePath);
         };
         this.deleteFile = (fileKey) => {
           Affirm_default(this._path, "Path not initialized");
           Affirm_default(fileKey, "Invalid file key");
-          const filePath = import_path9.default.join(this._path, fileKey);
-          if (fs13.existsSync(filePath)) {
-            fs13.unlinkSync(filePath);
+          const filePath = import_path10.default.join(this._path, fileKey);
+          if (fs14.existsSync(filePath)) {
+            fs14.unlinkSync(filePath);
           }
         };
         this.ready = async (request) => {
@@ -46087,7 +46309,7 @@ var init_LocalSourceDriver = __esm({
             allFilePaths.push(...localPaths);
             onProgress?.((index + 1) / allFileKeys.length);
           }
-          return { files: allFilePaths.map((x2) => ({ fullUri: x2, fileSize: fs13.statSync(x2).size })) };
+          return { files: allFilePaths.map((x2) => ({ fullUri: x2, fileSize: fs14.statSync(x2).size })) };
         };
       }
     };
@@ -46095,22 +46317,23 @@ var init_LocalSourceDriver = __esm({
 });
 
 // ../../packages/drivers/src/files/LocalDestinationDriver.ts
-var fs14, import_crypto4, import_promises10, import_path10, LocalDestinationDriver;
+var fs15, import_crypto4, import_promises10, import_path11, LocalDestinationDriver;
 var init_LocalDestinationDriver = __esm({
   "../../packages/drivers/src/files/LocalDestinationDriver.ts"() {
-    fs14 = __toESM(require("fs"), 1);
+    fs15 = __toESM(require("fs"), 1);
     import_crypto4 = require("crypto");
     import_promises10 = __toESM(require("fs/promises"), 1);
-    import_path10 = __toESM(require("path"), 1);
+    import_path11 = __toESM(require("path"), 1);
     init_src();
     init_src2();
+    init_DriverHelper();
     LocalDestinationDriver = class {
       constructor() {
         this.init = async (source) => {
           Affirm_default(source, `Invalid source`);
           const fileURL = source.authentication["path"];
           Affirm_default(fileURL, `Missing file path in the authentication of source "${source.name}"`);
-          const exist = fs14.existsSync(fileURL);
+          const exist = fs15.existsSync(fileURL);
           Affirm_default(exist, `The path (${fileURL}) for source "${source.name}" does NOT exist.`);
           this._path = source.authentication["path"];
           return this;
@@ -46119,12 +46342,12 @@ var init_LocalDestinationDriver = __esm({
           Affirm_default(this._path, "Path not initialized");
           Affirm_default(fileKey, "Invalid file key");
           Affirm_default(content, "Invalid content");
-          const filePath = import_path10.default.join(this._path, fileKey);
-          const directory = import_path10.default.dirname(filePath);
-          if (!fs14.existsSync(directory)) {
-            fs14.mkdirSync(directory, { recursive: true });
+          const filePath = import_path11.default.join(this._path, fileKey);
+          const directory = import_path11.default.dirname(filePath);
+          if (!fs15.existsSync(directory)) {
+            fs15.mkdirSync(directory, { recursive: true });
           }
-          fs14.writeFileSync(filePath, content);
+          fs15.writeFileSync(filePath, content);
           return Promise.resolve();
         };
         this.copyFromS3 = async (s3Driver, sourceFileKey, destinationFileKey) => {
@@ -46151,11 +46374,14 @@ var init_LocalDestinationDriver = __esm({
           } catch {
           }
         };
-        this.move = async (fromPath, toName) => {
-          const toFilePath = import_path10.default.join(this._path, toName);
+        this.move = async (fromPath, toName, header) => {
+          const toFilePath = import_path11.default.join(this._path, toName);
           const stagingPath = this._stagingPath(toFilePath);
           try {
-            await import_promises10.default.copyFile(fromPath, stagingPath);
+            if (header)
+              await DriverHelper_default.copyWithHeader(fromPath, stagingPath, header);
+            else
+              await import_promises10.default.copyFile(fromPath, stagingPath);
             await import_promises10.default.rename(stagingPath, toFilePath);
             await import_promises10.default.unlink(fromPath);
             return { bucket: "", key: toFilePath, res: true };
@@ -46165,12 +46391,14 @@ var init_LocalDestinationDriver = __esm({
             return { bucket: "", key: "", res: false };
           }
         };
-        this.transformAndMove = async (fromPath, transform, toName) => {
-          const toFilePath = import_path10.default.join(this._path, toName);
+        this.transformAndMove = async (fromPath, transform, toName, header) => {
+          const toFilePath = import_path11.default.join(this._path, toName);
           const stagingPath = this._stagingPath(toFilePath);
           try {
-            const reader = fs14.createReadStream(fromPath);
-            const writer = new BatchWriter_default(fs14.createWriteStream(stagingPath));
+            const reader = fs15.createReadStream(fromPath);
+            const writer = new BatchWriter_default(fs15.createWriteStream(stagingPath));
+            if (header)
+              writer.write(header);
             for await (const line of readLines(reader)) {
               if (!writer.write(transform(line)))
                 await writer.waitForDrain();
@@ -46304,7 +46532,7 @@ var init_StreamReader = __esm({
 });
 
 // ../../packages/drivers/src/s3/S3SourceDriver.ts
-var import_client_s32, import_stream3, import_promises11, import_path11, import_fs13, S3SourceDriver;
+var import_client_s32, import_stream3, import_promises11, import_path12, import_fs14, S3SourceDriver;
 var init_S3SourceDriver = __esm({
   "../../packages/drivers/src/s3/S3SourceDriver.ts"() {
     import_client_s32 = require("@aws-sdk/client-s3");
@@ -46312,8 +46540,8 @@ var init_S3SourceDriver = __esm({
     init_AwsCredentials();
     import_stream3 = require("stream");
     import_promises11 = require("stream/promises");
-    import_path11 = __toESM(require("path"), 1);
-    import_fs13 = __toESM(require("fs"), 1);
+    import_path12 = __toESM(require("path"), 1);
+    import_fs14 = __toESM(require("fs"), 1);
     init_src6();
     init_StreamReader();
     init_src4();
@@ -46473,9 +46701,9 @@ var init_S3SourceDriver = __esm({
             });
             const response = await this._client.send(command5);
             Affirm_default(response.Body, `Failed to fetch object "${s3Key}" from S3`);
-            const fileDir = import_path11.default.dirname(localPath);
-            if (!import_fs13.default.existsSync(fileDir)) {
-              import_fs13.default.mkdirSync(fileDir, { recursive: true });
+            const fileDir = import_path12.default.dirname(localPath);
+            if (!import_fs14.default.existsSync(fileDir)) {
+              import_fs14.default.mkdirSync(fileDir, { recursive: true });
             }
             const totalBytes = response.ContentLength ?? 0;
             let stagedBytes = 0;
@@ -46487,7 +46715,7 @@ var init_S3SourceDriver = __esm({
                 done(null, chunk);
               }
             });
-            const writeStream = import_fs13.default.createWriteStream(localPath);
+            const writeStream = import_fs14.default.createWriteStream(localPath);
             await (0, import_promises11.pipeline)(response.Body, meter, writeStream);
             report(1);
           };
@@ -46501,12 +46729,12 @@ var init_S3SourceDriver = __esm({
               await streamToFile(s3Key, localPath, (fraction) => onProgress?.((index + fraction) / allFileKeys.length));
               allFilePaths.push(localPath);
             }
-            return { files: allFilePaths.map((x2) => ({ fullUri: x2, fileSize: import_fs13.default.statSync(x2).size })) };
+            return { files: allFilePaths.map((x2) => ({ fullUri: x2, fileSize: import_fs14.default.statSync(x2).size })) };
           } else {
             const localPath = ExecutorScope_default.getProducerPath(scope, producer, fileKey);
             ExecutorScope_default.ensurePath(localPath);
             await streamToFile(fileKey, localPath, (fraction) => onProgress?.(fraction));
-            return { files: [{ fullUri: localPath, fileSize: import_fs13.default.statSync(localPath).size }] };
+            return { files: [{ fullUri: localPath, fileSize: import_fs14.default.statSync(localPath).size }] };
           }
         };
       }
@@ -46515,7 +46743,7 @@ var init_S3SourceDriver = __esm({
 });
 
 // ../../packages/drivers/src/s3/S3DestinationDriver.ts
-var import_client_s33, import_path12, import_fs14, S3DestinationDriver;
+var import_client_s33, import_path13, import_fs15, S3DestinationDriver;
 var init_S3DestinationDriver = __esm({
   "../../packages/drivers/src/s3/S3DestinationDriver.ts"() {
     import_client_s33 = require("@aws-sdk/client-s3");
@@ -46523,8 +46751,8 @@ var init_S3DestinationDriver = __esm({
     init_src2();
     init_src4();
     init_AwsCredentials();
-    import_path12 = __toESM(require("path"), 1);
-    import_fs14 = __toESM(require("fs"), 1);
+    import_path13 = __toESM(require("path"), 1);
+    import_fs15 = __toESM(require("fs"), 1);
     S3DestinationDriver = class {
       constructor() {
         this.init = async (source) => {
@@ -46557,26 +46785,33 @@ var init_S3DestinationDriver = __esm({
             Body: content
           }));
         };
-        this.move = async (fromPath, toName) => {
+        this.move = async (fromPath, toName, header) => {
           Affirm_default(fromPath, "Invalid source path");
           Affirm_default(toName, "Invalid destination name");
-          Affirm_default(import_fs14.default.existsSync(fromPath), `Source file does not exist: ${fromPath}`);
-          const readStream = import_fs14.default.createReadStream(fromPath);
-          return this._multipartUpload(toName, readStream);
+          Affirm_default(import_fs15.default.existsSync(fromPath), `Source file does not exist: ${fromPath}`);
+          const readStream = import_fs15.default.createReadStream(fromPath);
+          return this._multipartUpload(toName, header ? this._behindHeader(header, readStream) : readStream);
         };
-        this.transformAndMove = async (fromPath, transform, toName) => {
+        this.transformAndMove = async (fromPath, transform, toName, header) => {
           Affirm_default(fromPath, "Invalid source path");
           Affirm_default(transform, "Invalid transform function");
           Affirm_default(toName, "Invalid destination name");
-          Affirm_default(import_fs14.default.existsSync(fromPath), `Source file does not exist: ${fromPath}`);
-          const reader = import_fs14.default.createReadStream(fromPath);
+          Affirm_default(import_fs15.default.existsSync(fromPath), `Source file does not exist: ${fromPath}`);
+          const reader = import_fs15.default.createReadStream(fromPath);
           const transformedLines = async function* () {
+            if (header)
+              yield header + "\n";
             for await (const line of readLines(reader)) {
               yield transform(line) + "\n";
             }
           };
           return this._multipartUpload(toName, transformedLines());
         };
+        /** The file's own bytes behind its header line, so an untransformed upload stays a byte stream. */
+        this._behindHeader = async function* (header, source) {
+          yield header + "\n";
+          yield* source;
+        };
         this._multipartUpload = async (toName, dataSource) => {
           let uploadId;
           try {
@@ -46620,7 +46855,7 @@ var init_S3DestinationDriver = __esm({
               await this._abortUpload(toName, uploadId);
               uploadId = void 0;
               await this.saveFile(toName, Buffer.alloc(0));
-              return { res: true, key: import_path12.default.join(this._bucketName, toName), bucket: this._bucketName };
+              return { res: true, key: import_path13.default.join(this._bucketName, toName), bucket: this._bucketName };
             }
             const completeRes = await this._client.send(new import_client_s33.CompleteMultipartUploadCommand({
               Bucket: this._bucketName,
@@ -46631,7 +46866,7 @@ var init_S3DestinationDriver = __esm({
               }
             }));
             Affirm_default(completeRes.$metadata.httpStatusCode === 200, `Failed to complete multipart upload for "${toName}": status code ${completeRes.$metadata.httpStatusCode}`);
-            return { res: true, key: import_path12.default.join(this._bucketName, toName), bucket: this._bucketName };
+            return { res: true, key: import_path13.default.join(this._bucketName, toName), bucket: this._bucketName };
           } catch (error) {
             if (uploadId)
               await this._abortUpload(toName, uploadId);
@@ -46783,9 +47018,9 @@ var init_UrlMinter = __esm({
           return config;
         };
         /** Walks a dot path (`data.uploadUrl`) into the response, answering undefined rather than throwing. */
-        this._resolve = (payload, path20) => {
+        this._resolve = (payload, path22) => {
           let current = payload;
-          for (const segment of path20.split(".")) {
+          for (const segment of path22.split(".")) {
             if (current === null || typeof current !== "object")
               return void 0;
             current = current[segment];
@@ -46800,7 +47035,7 @@ var init_UrlMinter = __esm({
 });
 
 // ../../packages/drivers/src/presigned/PresignedUrlSourceDriver.ts
-var import_stream4, import_promises12, import_fs15, MAX_ERROR_BODY_CHARS2, PresignedUrlSourceDriver;
+var import_stream4, import_promises12, import_fs16, MAX_ERROR_BODY_CHARS2, PresignedUrlSourceDriver;
 var init_PresignedUrlSourceDriver = __esm({
   "../../packages/drivers/src/presigned/PresignedUrlSourceDriver.ts"() {
     init_src();
@@ -46808,7 +47043,7 @@ var init_PresignedUrlSourceDriver = __esm({
     init_src2();
     import_stream4 = require("stream");
     import_promises12 = require("stream/promises");
-    import_fs15 = __toESM(require("fs"), 1);
+    import_fs16 = __toESM(require("fs"), 1);
     init_StreamReader();
     init_UrlMinter();
     MAX_ERROR_BODY_CHARS2 = 500;
@@ -46890,9 +47125,9 @@ var init_PresignedUrlSourceDriver = __esm({
               done(null, chunk);
             }
           });
-          await (0, import_promises12.pipeline)(import_stream4.Readable.fromWeb(response.body), meter, import_fs15.default.createWriteStream(localPath));
+          await (0, import_promises12.pipeline)(import_stream4.Readable.fromWeb(response.body), meter, import_fs16.default.createWriteStream(localPath));
           onProgress?.(1);
-          const fileSize = import_fs15.default.statSync(localPath).size;
+          const fileSize = import_fs16.default.statSync(localPath).size;
           Logger_default.info(`Staged "${fileKey}" from a signed URL to ${localPath} (${fileSize} bytes)`);
           return { files: [{ fullUri: localPath, fileSize }] };
         };
@@ -46932,7 +47167,7 @@ var init_PresignedUrlSourceDriver = __esm({
 });
 
 // ../../packages/drivers/src/presigned/PresignedUrlDestinationDriver.ts
-var import_stream5, import_crypto5, import_promises13, import_fs16, MAX_ERROR_BODY_CHARS3, PresignedUrlDestinationDriver;
+var import_stream5, import_crypto5, import_promises13, import_fs17, MAX_ERROR_BODY_CHARS3, PresignedUrlDestinationDriver;
 var init_PresignedUrlDestinationDriver = __esm({
   "../../packages/drivers/src/presigned/PresignedUrlDestinationDriver.ts"() {
     init_src();
@@ -46941,8 +47176,9 @@ var init_PresignedUrlDestinationDriver = __esm({
     import_stream5 = require("stream");
     import_crypto5 = require("crypto");
     import_promises13 = __toESM(require("fs/promises"), 1);
-    import_fs16 = __toESM(require("fs"), 1);
+    import_fs17 = __toESM(require("fs"), 1);
     init_UrlMinter();
+    init_DriverHelper();
     MAX_ERROR_BODY_CHARS3 = 500;
     PresignedUrlDestinationDriver = class {
       constructor() {
@@ -46955,25 +47191,31 @@ var init_PresignedUrlDestinationDriver = __esm({
           Logger_default.log(`Presigned URL destination "${source.name}" initialised: minting endpoint=${UrlMinter_default.safeUrl(SecretManager_default.replaceSecret(source.authentication.url))}`);
           return this;
         };
-        this.move = async (fromPath, toName) => {
+        this.move = async (fromPath, toName, header) => {
           Affirm_default(fromPath, "Invalid source path");
           Affirm_default(toName, "Invalid destination name");
-          Affirm_default(import_fs16.default.existsSync(fromPath), `Source file does not exist: ${fromPath}`);
+          Affirm_default(import_fs17.default.existsSync(fromPath), `Source file does not exist: ${fromPath}`);
+          const stagingPath = `${fromPath}.${(0, import_crypto5.randomUUID)()}.partial`;
           try {
-            return await this._upload(fromPath, toName);
+            if (!header)
+              return await this._upload(fromPath, toName);
+            await DriverHelper_default.copyWithHeader(fromPath, stagingPath, header);
+            return await this._upload(stagingPath, toName);
           } catch (error) {
             Logger_default.error(`Presigned upload of "${toName}" from source "${this._source.name}" failed: ${error}`);
             return { res: false, key: "", bucket: "" };
+          } finally {
+            await this._discardStaging(stagingPath);
           }
         };
-        this.transformAndMove = async (fromPath, transform, toName) => {
+        this.transformAndMove = async (fromPath, transform, toName, header) => {
           Affirm_default(fromPath, "Invalid source path");
           Affirm_default(transform, "Invalid transform function");
           Affirm_default(toName, "Invalid destination name");
-          Affirm_default(import_fs16.default.existsSync(fromPath), `Source file does not exist: ${fromPath}`);
+          Affirm_default(import_fs17.default.existsSync(fromPath), `Source file does not exist: ${fromPath}`);
           const stagingPath = `${fromPath}.${(0, import_crypto5.randomUUID)()}.partial`;
           try {
-            await this._stageTransformed(fromPath, transform, stagingPath);
+            await this._stageTransformed(fromPath, transform, stagingPath, header);
             return await this._upload(stagingPath, toName);
           } catch (error) {
             Logger_default.error(`Presigned upload of "${toName}" from source "${this._source.name}" failed: ${error}`);
@@ -46984,11 +47226,11 @@ var init_PresignedUrlDestinationDriver = __esm({
         };
         this._upload = async (fromPath, toName) => {
           const minted = await UrlMinter_default.mint(this._auth, toName);
-          const fileSize = import_fs16.default.statSync(fromPath).size;
+          const fileSize = import_fs17.default.statSync(fromPath).size;
           const options2 = {
             method: this._auth.signedUrlMethod || "PUT",
             headers: { ...minted.headers, "content-length": String(fileSize) },
-            body: import_stream5.Readable.toWeb(import_fs16.default.createReadStream(fromPath)),
+            body: import_stream5.Readable.toWeb(import_fs17.default.createReadStream(fromPath)),
             duplex: "half"
           };
           const response = await fetch(minted.url, options2);
@@ -47001,9 +47243,11 @@ var init_PresignedUrlDestinationDriver = __esm({
           return { res: true, key: toName, bucket: this._host(minted.url) };
         };
         /** Writes the transformed lines to their own file, so the upload has a size to declare. */
-        this._stageTransformed = async (fromPath, transform, stagingPath) => {
-          const reader = import_fs16.default.createReadStream(fromPath);
-          const writer = new BatchWriter_default(import_fs16.default.createWriteStream(stagingPath));
+        this._stageTransformed = async (fromPath, transform, stagingPath, header) => {
+          const reader = import_fs17.default.createReadStream(fromPath);
+          const writer = new BatchWriter_default(import_fs17.default.createWriteStream(stagingPath));
+          if (header)
+            writer.write(header);
           for await (const line of readLines(reader)) {
             if (!writer.write(transform(line)))
               await writer.waitForDrain();
@@ -47599,10 +47843,10 @@ var init_LineParser = __esm({
 });
 
 // ../../packages/engines/src/producer/ProducerEngine.ts
-var import_path13, import_crypto6, noopTracker, ProducerEngineClass, ProducerEngine, ProducerEngine_default;
+var import_path14, import_crypto6, noopTracker, ProducerEngineClass, ProducerEngine, ProducerEngine_default;
 var init_ProducerEngine = __esm({
   "../../packages/engines/src/producer/ProducerEngine.ts"() {
-    import_path13 = __toESM(require("path"), 1);
+    import_path14 = __toESM(require("path"), 1);
     import_crypto6 = require("crypto");
     init_src();
     init_src8();
@@ -47710,13 +47954,13 @@ var init_ProducerEngine = __esm({
                   const driver = await DriverFactory_default.instantiateSource(source);
                   const readyResult = await driver.ready({ producer, scope });
                   const firstFile = readyResult.files[0].fullUri;
-                  const decompressedDir = import_path13.default.dirname(firstFile);
+                  const decompressedDir = import_path14.default.dirname(firstFile);
                   effectiveSource = { ...source, engine: "local", authentication: { ...source.authentication, path: decompressedDir } };
                   effectiveProducer = {
                     ...producer,
                     settings: {
                       ...producer.settings,
-                      fileKey: readyResult.files.length > 1 ? "%.dataset" : import_path13.default.basename(firstFile),
+                      fileKey: readyResult.files.length > 1 ? "%.dataset" : import_path14.default.basename(firstFile),
                       compressionType: void 0
                     }
                   };
@@ -47742,7 +47986,7 @@ var init_ProducerEngine = __esm({
           const firstItem = rawData[0];
           const isLineData = typeof firstItem === "string";
           const fills = discover ? [] : ProducerManager_default.compileFills(this._fillDimensions(producer));
-          const sourceFilename = import_path13.default.basename(producer.settings.fileKey ?? producer.settings.sqlTable ?? "");
+          const sourceFilename = import_path14.default.basename(producer.settings.fileKey ?? producer.settings.sqlTable ?? "");
           if (isLineData) {
             const lines = rawData;
             const dimensions = this.deriveDimensions(lines[0], producer, discover);
@@ -47949,7 +48193,7 @@ var init_DiscoverMerger = __esm({
 });
 
 // ../../packages/engines/src/ai/DeveloperEngine.ts
-var import_path14, import_promises14, import_dayjs2, import_customParseFormat2, DeveloperEngineClass, DeveloperEngine, DeveloperEngine_default;
+var import_path15, import_promises14, import_dayjs2, import_customParseFormat2, DeveloperEngineClass, DeveloperEngine, DeveloperEngine_default;
 var init_DeveloperEngine = __esm({
   "../../packages/engines/src/ai/DeveloperEngine.ts"() {
     init_src();
@@ -47957,7 +48201,7 @@ var init_DeveloperEngine = __esm({
     init_DiscoverMerger();
     init_src4();
     init_src8();
-    import_path14 = __toESM(require("path"), 1);
+    import_path15 = __toESM(require("path"), 1);
     import_promises14 = __toESM(require("fs/promises"), 1);
     import_dayjs2 = __toESM(require("dayjs"), 1);
     import_customParseFormat2 = __toESM(require("dayjs/plugin/customParseFormat"), 1);
@@ -47984,7 +48228,7 @@ var init_DeveloperEngine = __esm({
           const discovered = typeDefinitions.map(this.toDimension);
           const { dimensions, report } = DiscoverMerger_default.merge(authored.dimensions ?? [], discovered, mode);
           const mappedProducer = { ...authored, dimensions };
-          await import_promises14.default.mkdir(import_path14.default.dirname(producerPath), { recursive: true });
+          await import_promises14.default.mkdir(import_path15.default.dirname(producerPath), { recursive: true });
           await import_promises14.default.writeFile(producerPath, `${JSON.stringify(mappedProducer, null, 4)}
 `, "utf-8");
           return { producer: mappedProducer, fields: typeDefinitions, report };
@@ -50567,12 +50811,12 @@ var init_MockDataFactory = __esm({
 });
 
 // ../../packages/engines/src/mock/SyntheticInputEngine.ts
-var import_promises15, import_os, import_path15, import_dayjs4, import_customParseFormat3, import_utc3, POOL_CAP, SyntheticInputEngineClass, SyntheticInputEngine;
+var import_promises15, import_os, import_path16, import_dayjs4, import_customParseFormat3, import_utc3, POOL_CAP, SyntheticInputEngineClass, SyntheticInputEngine;
 var init_SyntheticInputEngine = __esm({
   "../../packages/engines/src/mock/SyntheticInputEngine.ts"() {
     import_promises15 = __toESM(require("fs/promises"), 1);
     import_os = __toESM(require("os"), 1);
-    import_path15 = __toESM(require("path"), 1);
+    import_path16 = __toESM(require("path"), 1);
     import_dayjs4 = __toESM(require("dayjs"), 1);
     import_customParseFormat3 = __toESM(require("dayjs/plugin/customParseFormat"), 1);
     import_utc3 = __toESM(require("dayjs/plugin/utc"), 1);
@@ -50596,7 +50840,7 @@ var init_SyntheticInputEngine = __esm({
           for (const cs2 of [...BUILTIN_CODE_SETS, ...codeSets]) codeSetMap.set(cs2.name.toLowerCase(), cs2);
           const producerMap = new Map(producers.map((p5) => [p5.name, p5]));
           const refTargets = this._collectReferences(producers, producerMap);
-          const dir = await import_promises15.default.mkdtemp(import_path15.default.join(import_os.default.tmpdir(), "remora-synth-"));
+          const dir = await import_promises15.default.mkdtemp(import_path16.default.join(import_os.default.tmpdir(), "remora-synth-"));
           const poolSize = Math.min(Math.max(opts.records, 1), POOL_CAP);
           const registry = new MockKeyRegistry();
           const specs = producers.flatMap((p5) => this._specs(p5, codeSetMap, producerMap, refTargets));
@@ -50662,7 +50906,7 @@ var init_SyntheticInputEngine = __esm({
             }
             lines.push(JSON.stringify(row) + "\n");
           }
-          const filePath = import_path15.default.join(dir, `${producer.name}.jsonl`);
+          const filePath = import_path16.default.join(dir, `${producer.name}.jsonl`);
           await import_promises15.default.writeFile(filePath, lines.join(""), "utf-8");
           const { size } = await import_promises15.default.stat(filePath);
           return { path: filePath, fileSize: size };
@@ -51494,33 +51738,33 @@ var init_RequestValidator = __esm({
         this.resolveMembers = (consumer) => {
           return new Set(ConsumerManager_default.getExpandedFields(consumer).map((x2) => x2.finalKey));
         };
-        this.checkFilters = (value, context, path20, depth) => {
+        this.checkFilters = (value, context, path22, depth) => {
           const { MAX_REQUEST_FILTERS, MAX_REQUEST_FILTER_DEPTH } = Constants_default.defaults;
           if (!Array.isArray(value))
-            throw new Error(`Invalid "${path20}": expected an array of filters, got ${this.describe(value)}`);
+            throw new Error(`Invalid "${path22}": expected an array of filters, got ${this.describe(value)}`);
           if (value.length > MAX_REQUEST_FILTERS)
-            throw new Error(`Invalid "${path20}": ${value.length} filters is above the maximum of ${MAX_REQUEST_FILTERS}`);
+            throw new Error(`Invalid "${path22}": ${value.length} filters is above the maximum of ${MAX_REQUEST_FILTERS}`);
           if (depth > MAX_REQUEST_FILTER_DEPTH)
-            throw new Error(`Invalid filter at ${path20}: filters may not nest more than ${MAX_REQUEST_FILTER_DEPTH} deep`);
-          return value.map((x2, index) => this.checkFilter(x2, context, `${path20}[${index}]`, depth));
+            throw new Error(`Invalid filter at ${path22}: filters may not nest more than ${MAX_REQUEST_FILTER_DEPTH} deep`);
+          return value.map((x2, index) => this.checkFilter(x2, context, `${path22}[${index}]`, depth));
         };
-        this.checkFilter = (value, context, path20, depth) => {
+        this.checkFilter = (value, context, path22, depth) => {
           if (!value || typeof value !== "object" || Array.isArray(value))
-            throw new Error(`Invalid filter at ${path20}: expected an object, got ${this.describe(value)}`);
+            throw new Error(`Invalid filter at ${path22}: expected an object, got ${this.describe(value)}`);
           const filter = value;
           const unknownKey = Object.keys(filter).find((key) => !FILTER_KEYS.includes(key));
           if (unknownKey)
-            throw new Error(`Invalid filter at ${path20}: unknown property "${unknownKey}". Supported: ${FILTER_KEYS.join(", ")}`);
-          const operator = this.checkOperator(filter.operator, path20);
+            throw new Error(`Invalid filter at ${path22}: unknown property "${unknownKey}". Supported: ${FILTER_KEYS.join(", ")}`);
+          const operator = this.checkOperator(filter.operator, path22);
           const checked = {
-            member: this.checkMember(filter.member, context, path20),
+            member: this.checkMember(filter.member, context, path22),
             operator,
-            values: this.checkValues(filter.values, operator, path20)
+            values: this.checkValues(filter.values, operator, path22)
           };
           if (Algo_default.hasVal(filter.and))
-            checked.and = this.checkFilters(filter.and, context, `${path20}.and`, depth + 1);
+            checked.and = this.checkFilters(filter.and, context, `${path22}.and`, depth + 1);
           if (Algo_default.hasVal(filter.or))
-            checked.or = this.checkFilters(filter.or, context, `${path20}.or`, depth + 1);
+            checked.or = this.checkFilters(filter.or, context, `${path22}.or`, depth + 1);
           return checked;
         };
         /**
@@ -51528,18 +51772,18 @@ var init_RequestValidator = __esm({
          * own field names by the time filters run, so any other name reads `undefined` and quietly keeps
          * every row (or drops every row, for a negated operator).
          */
-        this.checkMember = (value, context, path20) => {
+        this.checkMember = (value, context, path22) => {
           if (typeof value !== "string" || value.length === 0)
-            throw new Error(`Invalid filter at ${path20}: "member" must be a non-empty string, got ${this.describe(value)}`);
+            throw new Error(`Invalid filter at ${path22}: "member" must be a non-empty string, got ${this.describe(value)}`);
           if (!context.members.has(value))
-            throw new Error(`Invalid filter at ${path20}: consumer "${context.consumer.name}" has no field named "${value}"`);
+            throw new Error(`Invalid filter at ${path22}: consumer "${context.consumer.name}" has no field named "${value}"`);
           return value;
         };
-        this.checkOperator = (value, path20) => {
+        this.checkOperator = (value, path22) => {
           if (typeof value !== "string" || !VALUES_BY_OPERATOR.has(value))
-            throw new Error(`Invalid filter at ${path20}: unknown operator ${this.describe(value)}. Supported: ${this.supportedOperators()}`);
+            throw new Error(`Invalid filter at ${path22}: unknown operator ${this.describe(value)}. Supported: ${this.supportedOperators()}`);
           if (VALUES_BY_OPERATOR.get(value) === "unsupported")
-            throw new Error(`Invalid filter at ${path20}: operator "${value}" is not supported by a run`);
+            throw new Error(`Invalid filter at ${path22}: operator "${value}" is not supported by a run`);
           return value;
         };
         /**
@@ -51547,24 +51791,24 @@ var init_RequestValidator = __esm({
          * own type and the filter's is read back into it, so a number or a boolean here is a client bug
          * that reads as a type mismatch (matching nothing) rather than as the comparison it meant.
          */
-        this.checkValues = (value, operator, path20) => {
+        this.checkValues = (value, operator, path22) => {
           const values = Algo_default.hasVal(value) ? value : [];
           if (!Array.isArray(values))
-            throw new Error(`Invalid filter at ${path20}: "values" must be an array of strings, got ${this.describe(value)}`);
+            throw new Error(`Invalid filter at ${path22}: "values" must be an array of strings, got ${this.describe(value)}`);
           const wrongIndex = values.findIndex((x2) => typeof x2 !== "string");
           if (wrongIndex >= 0)
-            throw new Error(`Invalid filter at ${path20}: "values[${wrongIndex}]" must be a string, got ${this.describe(values[wrongIndex])}`);
-          return this.checkArity(values, operator, path20);
+            throw new Error(`Invalid filter at ${path22}: "values[${wrongIndex}]" must be a string, got ${this.describe(values[wrongIndex])}`);
+          return this.checkArity(values, operator, path22);
         };
-        this.checkArity = (values, operator, path20) => {
+        this.checkArity = (values, operator, path22) => {
           const expected = VALUES_BY_OPERATOR.get(operator);
           const reason = `operator "${operator}"`;
           if (expected === "none" && values.length > 0)
-            throw new Error(`Invalid filter at ${path20}: ${reason} reads no values, ${values.length} given`);
+            throw new Error(`Invalid filter at ${path22}: ${reason} reads no values, ${values.length} given`);
           if (expected === "many" && values.length === 0)
-            throw new Error(`Invalid filter at ${path20}: ${reason} needs at least one value, none given`);
+            throw new Error(`Invalid filter at ${path22}: ${reason} needs at least one value, none given`);
           if (typeof expected === "number" && values.length !== expected)
-            throw new Error(`Invalid filter at ${path20}: ${reason} needs exactly ${expected} ${expected === 1 ? "value" : "values"}, ${values.length} given`);
+            throw new Error(`Invalid filter at ${path22}: ${reason} needs exactly ${expected} ${expected === 1 ? "value" : "values"}, ${values.length} given`);
           return values;
         };
         /** Every operator a request may ask for, in the order they are declared. */
@@ -51905,23 +52149,23 @@ var init_Diagnostics = __esm({
           return [.../* @__PURE__ */ new Set([...inputs, ...chained])];
         };
         this._walk = (start, next, onCycle) => {
-          const path20 = [];
+          const path22 = [];
           const onPath = /* @__PURE__ */ new Set();
           const stack = [{ name: start, done: false }];
           const visited = /* @__PURE__ */ new Set();
           while (stack.length > 0) {
             const frame = stack.pop();
             if (frame.done) {
-              onPath.delete(path20.pop());
+              onPath.delete(path22.pop());
               continue;
             }
             if (onPath.has(frame.name)) {
-              path20.slice(path20.indexOf(frame.name)).forEach((name) => onCycle.add(name));
+              path22.slice(path22.indexOf(frame.name)).forEach((name) => onCycle.add(name));
               continue;
             }
             if (visited.has(frame.name)) continue;
             visited.add(frame.name);
-            path20.push(frame.name);
+            path22.push(frame.name);
             onPath.add(frame.name);
             stack.push({ name: frame.name, done: true });
             const successors = next.get(frame.name) ?? [];
@@ -52614,8 +52858,8 @@ var init_ResourceView = __esm({
           if (!source || origin.path.length < 2) return { value: "declared here", muted: true };
           return { value: `${source.resource}.${source.field}`, link: source.node };
         };
-        this._pathText = (path20) => {
-          return path20.map((step) => `${step.resource}.${step.field}`).join(" \u2192 ");
+        this._pathText = (path22) => {
+          return path22.map((step) => `${step.resource}.${step.field}`).join(" \u2192 ");
         };
         this._consumerOutputsTable = (env2, consumer) => {
           const declared = new Set((env2.sources ?? []).map((x2) => x2.name));
@@ -52839,6 +53083,297 @@ var init_lineage = __esm({
   }
 });
 
+// ../../packages/engines/src/usage/LocalUsageDB.ts
+var import_fs18, import_path17, COLUMNS, CLI_DB_FOLDER, CLI_DB_FILE, CLI_DB_PATH, MAX_USAGE_ROWS, MAX_LISTED_ROWS, EXECUTED_BY_SCHEMA, EXECUTOR_OPERATION_SCHEMA, STATS_SCHEMA, COLUMN_SCHEMAS, LocalUsageDBClass, LocalUsageDB, LocalUsageDB_default;
+var init_LocalUsageDB = __esm({
+  "../../packages/engines/src/usage/LocalUsageDB.ts"() {
+    init_src();
+    import_fs18 = require("fs");
+    import_path17 = require("path");
+    COLUMNS = [
+      "_id",
+      "consumer",
+      "executedBy",
+      "startedAt",
+      "finishedAt",
+      "itemsCount",
+      "invokedBy",
+      "status",
+      "error",
+      "stats",
+      // Appended last on purpose: rows written before this column existed still decode positionally.
+      "engineVersion"
+    ];
+    CLI_DB_FOLDER = "./remora/.temp/usage";
+    CLI_DB_FILE = "remora_usage.csv";
+    CLI_DB_PATH = (0, import_path17.join)(CLI_DB_FOLDER, CLI_DB_FILE);
+    MAX_USAGE_ROWS = 1e4;
+    MAX_LISTED_ROWS = 500;
+    EXECUTED_BY_SCHEMA = {
+      _id: "string",
+      name: "string",
+      type: "string"
+    };
+    EXECUTOR_OPERATION_SCHEMA = {
+      elapsedMS: ["number"],
+      min: "number",
+      max: "number",
+      avg: "number"
+    };
+    STATS_SCHEMA = {
+      executionId: "string",
+      resultUri: "string",
+      elapsedMS: "number",
+      inputCount: "number",
+      outputCount: "number",
+      cycles: "number",
+      workerCount: "number",
+      operations: {
+        "*": EXECUTOR_OPERATION_SCHEMA
+      }
+    };
+    COLUMN_SCHEMAS = {
+      _id: "string",
+      consumer: "string",
+      executedBy: EXECUTED_BY_SCHEMA,
+      startedAt: "date",
+      finishedAt: "date",
+      itemsCount: "number",
+      invokedBy: "string",
+      status: "string",
+      error: "string",
+      stats: STATS_SCHEMA,
+      engineVersion: "string"
+    };
+    LocalUsageDBClass = class {
+      constructor() {
+        this._handleError = (action, error) => {
+          console.error(`LocalUsageDB ${action} failed:`, error);
+        };
+        this._splitSerialized = (value, separator) => {
+          if (!value)
+            return [];
+          const parts = [];
+          let current = "";
+          let quoteOpen = false;
+          let curlyDepth = 0;
+          let squareDepth = 0;
+          for (let index = 0; index < value.length; index++) {
+            const char = value[index];
+            const next = value[index + 1];
+            if (char === '"') {
+              current += char;
+              if (quoteOpen && next === '"') {
+                current += next;
+                index++;
+                continue;
+              }
+              quoteOpen = !quoteOpen;
+              continue;
+            }
+            if (!quoteOpen) {
+              if (char === "{")
+                curlyDepth++;
+              else if (char === "}")
+                curlyDepth--;
+              else if (char === "[")
+                squareDepth++;
+              else if (char === "]")
+                squareDepth--;
+              else if (char === separator && curlyDepth === 0 && squareDepth === 0) {
+                parts.push(current);
+                current = "";
+                continue;
+              }
+            }
+            current += char;
+          }
+          parts.push(current);
+          return parts;
+        };
+        this._splitKeyValue = (value) => {
+          let quoteOpen = false;
+          let curlyDepth = 0;
+          let squareDepth = 0;
+          for (let index = 0; index < value.length; index++) {
+            const char = value[index];
+            const next = value[index + 1];
+            if (char === '"') {
+              if (quoteOpen && next === '"') {
+                index++;
+                continue;
+              }
+              quoteOpen = !quoteOpen;
+              continue;
+            }
+            if (!quoteOpen) {
+              if (char === "{")
+                curlyDepth++;
+              else if (char === "}")
+                curlyDepth--;
+              else if (char === "[")
+                squareDepth++;
+              else if (char === "]")
+                squareDepth--;
+              else if (char === ":" && curlyDepth === 0 && squareDepth === 0)
+                return [value.slice(0, index), value.slice(index + 1)];
+            }
+          }
+          return [value, ""];
+        };
+        this._decodeString = (value) => {
+          if (!value)
+            return "";
+          if (value.startsWith('"') && value.endsWith('"'))
+            return value.slice(1, -1).replaceAll('""', '"');
+          return value;
+        };
+        this._decodeValue = (value, schema) => {
+          if (!value)
+            return null;
+          if (value.startsWith("{") && value.endsWith("}")) {
+            const objectSchema = schema && !Array.isArray(schema) && typeof schema === "object" ? schema : {};
+            const dynamicSchema = objectSchema["*"];
+            const serializedEntries = this._splitSerialized(value.slice(1, -1), ";");
+            const decodedObject = {};
+            serializedEntries.forEach((entry) => {
+              const [rawKey, rawValue] = this._splitKeyValue(entry);
+              const key = this._decodeString(rawKey);
+              decodedObject[key] = this._decodeValue(rawValue, objectSchema[key] ?? dynamicSchema);
+            });
+            return decodedObject;
+          }
+          if (value.startsWith("[") && value.endsWith("]")) {
+            const serializedItems = this._splitSerialized(value.slice(1, -1), ";");
+            const itemSchema = Array.isArray(schema) ? schema[0] : void 0;
+            return serializedItems.map((item) => this._decodeValue(item, itemSchema));
+          }
+          const decodedString = this._decodeString(value);
+          if (schema === "number")
+            return Number(decodedString);
+          if (schema === "date")
+            return decodedString ? new Date(decodedString) : null;
+          return decodedString;
+        };
+        this._encodeValue = (value) => {
+          if (value === null || value === void 0)
+            return "";
+          else if (value instanceof Date)
+            return `"${value.toISOString().replaceAll('"', '""')}"`;
+          else if (Array.isArray(value))
+            return `[${value.map((item) => this._encodeValue(item)).join(";")}]`;
+          else if (typeof value === "object")
+            return `{${Object.keys(value).map((key) => `${this._encodeValue(key)}:${this._encodeValue(value[key])}`).join(";")}}`;
+          else
+            return `"${(value ?? "").toString().replaceAll('"', '""')}"`;
+        };
+        this._toLine = (usage) => {
+          return COLUMNS.map((column) => this._encodeValue(usage[column])).join(",");
+        };
+        this._fromLine = (line) => {
+          const values = this._splitSerialized(line, ",");
+          const usage = {};
+          COLUMNS.forEach((column, index) => {
+            usage[column] = this._decodeValue(values[index] ?? "", COLUMN_SCHEMAS[column]);
+          });
+          return usage;
+        };
+        this._getRows = () => {
+          const lines = (0, import_fs18.readFileSync)(CLI_DB_PATH, "utf8").split("\n").filter(Boolean);
+          lines.shift();
+          return lines;
+        };
+        this._writeRows = (rows) => {
+          const trimmedRows = rows.slice(-MAX_USAGE_ROWS);
+          (0, import_fs18.writeFileSync)(CLI_DB_PATH, `${[COLUMNS.join(","), ...trimmedRows].join("\n")}
+`);
+        };
+        this.init = () => {
+          try {
+            if (!(0, import_fs18.existsSync)(CLI_DB_FOLDER))
+              (0, import_fs18.mkdirSync)(CLI_DB_FOLDER, { recursive: true });
+            if (!(0, import_fs18.existsSync)(CLI_DB_PATH))
+              (0, import_fs18.writeFileSync)(CLI_DB_PATH, `${COLUMNS.join(",")}
+`);
+            this._writeRows(this._getRows());
+          } catch (error) {
+            this._handleError("init", error);
+          }
+        };
+        this.insert = (usage) => {
+          try {
+            this.init();
+            this._writeRows([...this._getRows(), this._toLine(usage)]);
+          } catch (error) {
+            this._handleError("insert", error);
+          }
+        };
+        /**
+         * The recorded runs, newest first — the newest `limit` of the rows `keep` accepts.
+         *
+         * Decoded from the end and stopped as soon as that many are held: a reader wants the recent
+         * executions, and decoding ten thousand rows to show ten of them is work nobody asked for.
+         *
+         * `keep` is applied BEFORE the limit, which is the only way "the newest N runs of this kind" can
+         * mean it: filtering afterwards lets the rows a caller does not want displace the ones it does,
+         * so one sample recorded here would silently push a real run out of a history someone is reading.
+         *
+         * Never throws. A missing file reads as no history, and so does a half-written one — this store is
+         * appended to while it is being read, so failing on that would make it unreadable during a run.
+         */
+        this.list = (limit = MAX_LISTED_ROWS, keep) => {
+          try {
+            if (!(0, import_fs18.existsSync)(CLI_DB_PATH))
+              return [];
+            const rows = this._getRows();
+            const wanted = Math.max(1, limit);
+            const found = [];
+            for (let index = rows.length - 1; index >= 0 && found.length < wanted; index--) {
+              const usage = this._fromLine(rows[index]);
+              if (!keep || keep(usage)) found.push(usage);
+            }
+            return found;
+          } catch (error) {
+            this._handleError("list", error);
+            return [];
+          }
+        };
+        /**
+         * A token that changes whenever the store does, cheap enough to poll: a preview watching for a
+         * finished run must not decode the whole file once a second to notice one.
+         */
+        this.signature = () => {
+          try {
+            if (!(0, import_fs18.existsSync)(CLI_DB_PATH))
+              return "";
+            const stats = (0, import_fs18.statSync)(CLI_DB_PATH);
+            return `${stats.mtimeMs}:${stats.size}`;
+          } catch (error) {
+            this._handleError("signature", error);
+            return "";
+          }
+        };
+        this.update = (update) => {
+          try {
+            Affirm_default(update?._id, "Invalid usage update _id");
+            this.init();
+            const updatedLines = this._getRows().map((line) => {
+              const current = this._fromLine(line);
+              if (current._id !== update._id) return line;
+              return this._toLine({ ...current, ...update });
+            });
+            this._writeRows(updatedLines);
+          } catch (error) {
+            this._handleError("update", error);
+          }
+        };
+      }
+    };
+    LocalUsageDB = new LocalUsageDBClass();
+    LocalUsageDB_default = LocalUsageDB;
+  }
+});
+
 // ../../packages/database/src/DatabaseEngine.ts
 var import_mongodb, DatabaseEngineClass, DatabaseEngine, DatabaseEngine_default;
 var init_DatabaseEngine = __esm({
@@ -53186,6 +53721,481 @@ var init_RunRegistry = __esm({
   }
 });
 
+// ../../packages/engines/src/usage/UsageManager.ts
+var MAX_RECORDED_OPERATIONS, UsageManagerClass, UsageManager, UsageManager_default;
+var init_UsageManager = __esm({
+  "../../packages/engines/src/usage/UsageManager.ts"() {
+    init_src();
+    init_src3();
+    init_src();
+    init_src4();
+    init_src9();
+    init_src6();
+    init_src6();
+    init_src2();
+    init_RunRegistry();
+    init_LocalUsageDB();
+    MAX_RECORDED_OPERATIONS = 40;
+    UsageManagerClass = class {
+      constructor() {
+        this._shouldSkipDb = () => Helper_default.isDev() || !process.env.MONGO_URI;
+        this._shouldLogCLI = () => process.env.REMORA_RUNTIME_CONTEXT === "cli";
+        /**
+         * Whether this runtime keeps its execution records in the local file rather than in the usage
+         * collection. Public because a READER has to make the same decision the writer just made — two
+         * answers to "where are the runs" is one answer too many.
+         */
+        this.recordsLocally = () => this._shouldSkipDb() && this._shouldLogCLI();
+        this.startUsage = (consumer, details) => {
+          const { user, invokedBy } = details;
+          const newUsage = {
+            _id: Helper_default.uuid(),
+            consumer: consumer.name,
+            engineVersion: Constants_default.cliVersion,
+            startedAt: DSTE_default.now(),
+            executedBy: user,
+            itemsCount: -1,
+            status: "started",
+            invokedBy: invokedBy ?? "UNKNOWN",
+            _signature: "",
+            stats: null
+          };
+          RunRegistry_default.start({
+            executionId: newUsage._id,
+            consumer: newUsage.consumer,
+            invokedBy: newUsage.invokedBy,
+            userType: user?.type ?? "UNKNOWN",
+            startedAt: newUsage.startedAt
+          });
+          if (this._shouldSkipDb()) {
+            if (this._shouldLogCLI())
+              LocalUsageDB_default.insert(newUsage);
+            return { usageId: newUsage._id, usage: Promise.resolve(newUsage) };
+          }
+          const updateRes = DatabaseEngine_default.upsert(Settings_default.db.collections.usage, newUsage._id, newUsage);
+          return { usageId: newUsage._id, usage: updateRes };
+        };
+        this.endUsage = (usageId, itemsCount, stats) => {
+          const update = {
+            itemsCount,
+            status: "success",
+            finishedAt: DSTE_default.now(),
+            stats
+          };
+          this._emitRunRecord(usageId, "success", stats, null);
+          if (this._shouldSkipDb()) {
+            if (this._shouldLogCLI())
+              LocalUsageDB_default.update({ ...update, _id: usageId });
+            return { usageId: null, usage: Promise.resolve(update) };
+          }
+          const updateRes = DatabaseEngine_default.upsert(Settings_default.db.collections.usage, usageId, update);
+          return { usageId, usage: updateRes };
+        };
+        this.failUsage = (usageId, error) => {
+          const update = {
+            status: "failed",
+            error,
+            finishedAt: DSTE_default.now()
+          };
+          this._emitRunRecord(usageId, "failed", null, error);
+          if (this._shouldSkipDb()) {
+            if (this._shouldLogCLI())
+              LocalUsageDB_default.update({ ...update, _id: usageId });
+            return { usageId: null, usage: Promise.resolve(update) };
+          }
+          const updateRes = DatabaseEngine_default.upsert(Settings_default.db.collections.usage, usageId, update);
+          return { usageId, usage: updateRes };
+        };
+        /**
+         * Close out the in-flight entry and write one structured record for the finished run.
+         *
+         * This is the cheapest useful thing in the whole ops surface: the executor already hands us the
+         * complete result, so a single hook makes every run queryable in the log pipeline without a
+         * database. Never throws — reporting on a run must not be able to fail the run.
+         */
+        this._emitRunRecord = (usageId, status, stats, error) => {
+          Affirm_default(usageId, "Missing usage id");
+          try {
+            const run = RunRegistry_default.finish(usageId);
+            const record = {
+              executionId: usageId,
+              consumer: run?.consumer ?? null,
+              engineVersion: Constants_default.cliVersion,
+              project: Environment_default._env ? Environment_default.getProjectName() : null,
+              invokedBy: run?.invokedBy ?? null,
+              userType: run?.userType ?? null,
+              status,
+              startedAt: run?.startedAt?.toISOString() ?? null,
+              elapsedMS: stats?.elapsedMS ?? (run ? DSTE_default.now().getTime() - run.startedAt.getTime() : -1),
+              inputCount: stats?.inputCount ?? -1,
+              outputCount: stats?.outputCount ?? -1,
+              cycles: stats?.cycles ?? -1,
+              workerCount: stats?.workerCount ?? -1,
+              operations: this._summarizeOperations(stats),
+              error: error ?? null
+            };
+            StateEmitter_default.emit("run", record);
+          } catch {
+          }
+        };
+        /**
+         * Keep only min/max/avg per stage. The raw `elapsedMS` array holds one entry per worker chunk
+         * and can run to thousands of numbers on a large run — useless in a log line and unbounded.
+         */
+        this._summarizeOperations = (stats) => {
+          const operations = {};
+          if (!stats?.operations)
+            return operations;
+          for (const name of Object.keys(stats.operations).slice(0, MAX_RECORDED_OPERATIONS)) {
+            const operation2 = stats.operations[name];
+            operations[name] = { min: operation2.min, max: operation2.max, avg: operation2.avg };
+          }
+          return operations;
+        };
+      }
+    };
+    UsageManager = new UsageManagerClass();
+    UsageManager_default = UsageManager;
+  }
+});
+
+// ../../packages/engines/src/ops/BugReportBundle.ts
+var import_crypto7, import_fs19, import_adm_zip3, MAX_ENTRIES, BugReportBundle, BugReportBundle_default;
+var init_BugReportBundle = __esm({
+  "../../packages/engines/src/ops/BugReportBundle.ts"() {
+    import_crypto7 = __toESM(require("crypto"), 1);
+    import_fs19 = __toESM(require("fs"), 1);
+    import_adm_zip3 = __toESM(require("adm-zip"), 1);
+    init_src();
+    init_src2();
+    MAX_ENTRIES = 2e3;
+    BugReportBundle = class {
+      constructor() {
+        this._zip = new import_adm_zip3.default();
+        this._sections = /* @__PURE__ */ new Map();
+        /**
+         * Run one section's collection, and record what came of it.
+         *
+         * The section decides what it writes by calling `add`; this only decides what happens when it
+         * cannot. A thrown error becomes the section's `reason` — which is more useful in the bundle
+         * than it would have been on someone's terminal.
+         */
+        this.collect = (name, collector) => {
+          Affirm_default(name, "Missing required parameter name");
+          Affirm_default(collector, "Missing required parameter collector");
+          this._section(name);
+          try {
+            collector();
+          } catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            this.skip(name, `Collection failed: ${reason}`);
+            Logger_default.warn(`Bug report section "${name}" could not be collected: ${reason}`);
+          }
+        };
+        /** Write one file into the bundle, under the section that produced it. */
+        this.add = (name, path22, content) => {
+          Affirm_default(path22, "Missing required parameter path");
+          Affirm_default(content !== void 0 && content !== null, `No content for bundle entry ${path22}`);
+          const section = this._section(name);
+          Affirm_default(
+            this._zip.getEntries().length < MAX_ENTRIES,
+            `Bug report reached its ${MAX_ENTRIES} file limit while writing ${path22}`
+          );
+          this._zip.addFile(path22, Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8"));
+          section.included = true;
+          section.files.push(path22);
+        };
+        /** Record that a section contributed nothing, and why. Absence without a reason reads as a bug. */
+        this.skip = (name, reason) => {
+          Affirm_default(reason, `No reason given for skipping bug report section ${name}`);
+          const section = this._section(name);
+          section.included = section.files.length > 0;
+          section.reason = reason;
+        };
+        /** Whether a section wrote anything — the condition `report.md` renders its inventory from. */
+        this.has = (name) => this._section(name).included;
+        /** Every section, in the order they were collected. */
+        this.sections = () => [...this._sections.values()];
+        /** Every entry with its size and digest, so a reader can tell a truncated bundle from a short one. */
+        this.files = () => this._zip.getEntries().map((entry) => {
+          const data = entry.getData();
+          return {
+            path: entry.entryName,
+            bytes: data.length,
+            sha256: import_crypto7.default.createHash("sha256").update(data).digest("hex")
+          };
+        });
+        /**
+         * Write the archive and return its size on disk. The manifest is added here rather than by a
+         * section, because it inventories every other file and so has to be the last one in.
+         */
+        this.write = (outputPath, manifest) => {
+          Affirm_default(outputPath, "Missing required parameter outputPath");
+          Affirm_default(manifest, "Missing required parameter manifest");
+          this._zip.addFile("manifest.json", Buffer.from(JSON.stringify(manifest, null, 4), "utf8"));
+          this._zip.writeZip(outputPath);
+          return import_fs19.default.statSync(outputPath).size;
+        };
+        this._section = (name) => {
+          if (!this._sections.has(name))
+            this._sections.set(name, { name, included: false, files: [] });
+          return this._sections.get(name);
+        };
+      }
+    };
+    BugReportBundle_default = BugReportBundle;
+  }
+});
+
+// ../../packages/engines/src/ops/BugReportRenderer.ts
+var QUOTED_ERRORS, LISTED_OPERATIONS, LISTED_PROBLEMS, LISTED_FILES, BugReportRendererClass, BugReportRenderer, BugReportRenderer_default;
+var init_BugReportRenderer = __esm({
+  "../../packages/engines/src/ops/BugReportRenderer.ts"() {
+    init_src();
+    init_src6();
+    QUOTED_ERRORS = 3;
+    LISTED_OPERATIONS = 8;
+    LISTED_PROBLEMS = 20;
+    LISTED_FILES = 3;
+    BugReportRendererClass = class {
+      constructor() {
+        /** The one page a dev reads. Markdown, because it renders wherever a ticket does. */
+        this.report = (page) => {
+          Affirm_default(page, "Missing required parameter page");
+          Affirm_default(page.environment, "Missing environment in bug report page");
+          return [
+            this._header(page),
+            this._summary(page),
+            this._failure(page),
+            this._pipeline(page),
+            this._problems(page.environment.config.problems),
+            this._timings(page.run),
+            this._reproduction(page),
+            this._inventory(page.sections)
+          ].filter(Boolean).join("\n\n") + "\n";
+        };
+        /**
+         * The commands that reproduce the case, as POSIX sh.
+         *
+         * TEXT, never a file in the bundle. An executable inside an archive that travels by mail or
+         * ticket is what a gateway or an endpoint scanner quarantines, and a bundle that does not
+         * arrive reproduces nothing — so `report.md` carries this in a fenced block and the reader
+         * pastes it. It stays one definition rather than prose that drifts from what actually works,
+         * and it is still the dev tool it always was: save it as a file and run it.
+         */
+        this.repro = (repro) => {
+          Affirm_default(repro, "Missing required parameter repro");
+          const consumer = repro.consumer ?? "<consumer>";
+          return [
+            "# Run from the directory the bundle was unpacked into, with a valid",
+            "# REMORA_LICENCE_KEY in the environment.",
+            "#",
+            "# The input is SYNTHETIC: no row of the customer's data is in this bundle. The seed is",
+            "# fixed, so the same input is generated here and there \u2014 it reproduces the pipeline,",
+            "# not the values. Ask for a --capture bundle when the bug depends on what the data was.",
+            "set -e",
+            "",
+            "# 1. The configuration is the project",
+            "mkdir -p repro",
+            "cp -r config repro/remora",
+            "cd repro",
+            "",
+            "# 2. A placeholder for every {ENV_VAR} the configuration names.",
+            "#    `compile` refuses to run while a reference is unset, and the config came from a",
+            "#    machine that had them all \u2014 so without this the repro stops before it starts.",
+            "#    Placeholders are enough because `synth` contacts no source; put the real values",
+            "#    here before uncommenting the `run` at the end. Uppercase only, which is the",
+            "#    environment convention and keeps a producer's own {field}/{index} placeholders",
+            "#    out of a file that would otherwise claim the project needs a variable named key.",
+            "grep -rho '{[A-Z][A-Z0-9_]*}' remora/ | tr -d '{}' | sort -u \\",
+            "    | sed 's/$/=placeholder/' > .env || true",
+            "",
+            "# 3. The local paths the configuration points at, which were someone else's machine.",
+            "#    A destination directory that does not exist fails the export AFTER the run, which",
+            "#    reads as a second bug and is not one.",
+            `grep -rho '"path"[[:space:]]*:[[:space:]]*"[^"]*"' remora/sources/ 2>/dev/null \\`,
+            `    | sed 's/.*:[[:space:]]*"//; s/"$//' | sort -u \\`,
+            '    | while read -r directory; do mkdir -p "$directory" || true; done',
+            "",
+            "# 4. What the configuration says it is",
+            "remora compile",
+            "",
+            "# 5. The failing pipeline, on generated input",
+            `remora synth ${consumer} --records ${repro.records} --seed ${repro.seed}`,
+            "",
+            "# 6. The real thing, once the sources are reachable and the values above are real",
+            `# remora run ${consumer}`,
+            ""
+          ].join("\n");
+        };
+        this._header = (page) => {
+          const redaction = page.repro.syntheticData ? "no customer data" : "masked customer data";
+          return [
+            "# Remora bug report",
+            "",
+            `Bundle \`${page.bundleId}\` \xB7 collected ${page.createdAt} \xB7 remora ${page.remoraVersion} \xB7 ${redaction}`
+          ].join("\n");
+        };
+        this._summary = (page) => {
+          const { remora, platform: platform2, node, config } = page.environment;
+          const run = page.run;
+          const rows = [
+            ["Project", `${config.project ?? "(unreadable project.json)"} \`${config.signature ?? "\u2014"}\``],
+            ["Consumer", run?.consumer ? `\`${run.consumer}\`` : "none \u2014 no run history"],
+            ["Run", run ? `\`${run._id}\` \u2014 **${run.status}**${this._elapsed(run)}` : "none \u2014 no run history"],
+            ["Started", run?.startedAt ? this._iso(run.startedAt) : "\u2014"],
+            ["Rows", run ? `${this._count(run.stats?.inputCount)} in \u2192 ${this._count(run.itemsCount)} out` : "\u2014"],
+            ["Engine", `${run?.engineVersion ?? "unknown"} (collected by ${page.remoraVersion})`],
+            ["Machine", `${platform2.hostname ?? "unknown host"} \u2014 ${platform2.osType ?? platform2.platform} ${platform2.release}, ${platform2.arch}`],
+            ["CPU / RAM", `${platform2.cpuCount} \xD7 ${platform2.cpuModel ?? "unknown"}, ${platform2.totalMemoryMB} MB total (${platform2.freeMemoryMB} MB free at collection)`],
+            ["Time zone", `${platform2.timezone ?? "unknown"} \u2014 a datetime read here was read in this zone`],
+            ["Node", `${node.version} (v8 ${node.v8}, icu ${node.icu}, zlib ${node.zlib}, openssl ${node.openssl})`],
+            ["Heap", `${platform2.heapLimitMB} MB limit, ${remora.heapUsedMB} MB in use at collection`],
+            ["Runtime", this._settings(node)],
+            ["Config", config.loaded ? `${config.counts.sources} sources, ${config.counts.producers} producers, ${config.counts.consumers} consumers` : "**did not load** \u2014 see Configuration problems"]
+          ];
+          return ["## Summary", "", ...rows.map(([key, value]) => `- **${key}** \u2014 ${value}`)].join("\n");
+        };
+        /**
+         * The behaviour-changing variables, as `NAME=value`. Unset is itself the answer much of the
+         * time — a worker with no `REMORA_MAX_WORKERS` sized itself from memory — so it says so.
+         */
+        this._settings = (node) => {
+          const entries = Object.entries(node.settings ?? {});
+          if (!entries.length)
+            return "no behaviour-changing variables set \u2014 every default in force";
+          return entries.map(([name, value]) => `\`${name}=${value}\``).join(", ");
+        };
+        this._failure = (page) => {
+          const error = page.run?.error;
+          const logged = page.run?.status === "success" ? [] : page.log?.errors?.slice(-QUOTED_ERRORS) ?? [];
+          if (!error && !logged.length)
+            return page.run ? `## Failure
+
+The run reported no error \u2014 it finished **${page.run.status}**.` : null;
+          const parts = ["## Failure", ""];
+          if (error)
+            parts.push("```", error, "```");
+          if (logged.length)
+            parts.push("", `Last ${logged.length} error record${logged.length === 1 ? "" : "s"} in the log:`, "", "```", logged.join("\n"), "```");
+          return parts.join("\n");
+        };
+        /**
+         * What the run was made of — consumer, producers, sources and engines. The question behind
+         * nearly every report is "what was it talking to", and the answer is three joins away in
+         * config/, so it is resolved here instead.
+         */
+        this._pipeline = (page) => {
+          const { sources, producers, consumers } = page.environment.config;
+          const consumer = consumers.find((x2) => x2.name === page.run?.consumer);
+          if (!consumer)
+            return sources.length ? ["## Pipeline", "", ...sources.map((x2) => `- source **${x2.name}** \u2014 \`${x2.engine}\`, auth \`${x2.authMethod ?? "none"}\``)].join("\n") : null;
+          const lines = [`- consumer **${consumer.name}** \u2192 ${consumer.outputs.join(", ") || "no outputs"}`];
+          for (const name of consumer.producers) {
+            const producer = producers.find((x2) => x2.name === name);
+            if (!producer) {
+              lines.push(`  - producer **${name}** \u2014 *not found in the configuration*`);
+              continue;
+            }
+            const source = sources.find((x2) => x2.name === producer.source);
+            const described = source ? `source **${source.name}** (\`${source.engine}\`, auth \`${source.authMethod ?? "none"}\`)` : `source **${producer.source}** \u2014 *not found in the configuration*`;
+            lines.push(`  - producer **${producer.name}** (${producer.dimensionCount} dimensions) \u2190 ${described}`);
+          }
+          return ["## Pipeline", "", ...lines].join("\n");
+        };
+        this._problems = (problems) => {
+          if (!problems?.length)
+            return "## Configuration problems\n\nNone \u2014 the project read cleanly.";
+          const listed = problems.slice(0, LISTED_PROBLEMS).map((problem) => {
+            const where = problem.resource ? `${problem.resource.kind} \`${problem.resource.name}\`` : problem.file ?? problem.scope;
+            return `- **${problem.severity}** ${where} \u2014 ${problem.message}`;
+          });
+          if (problems.length > LISTED_PROBLEMS)
+            listed.push(`- \u2026and ${problems.length - LISTED_PROBLEMS} more`);
+          return ["## Configuration problems", "", ...listed].join("\n");
+        };
+        this._timings = (run) => {
+          const operations = Object.entries(run?.stats?.operations ?? {});
+          if (!operations.length)
+            return null;
+          const rows = operations.sort((left, right) => (right[1].max ?? 0) - (left[1].max ?? 0)).slice(0, LISTED_OPERATIONS).map(([name, timing2]) => `| \`${name}\` | ${timing2.elapsedMS?.length ?? 0} | ${Helper_default.formatDuration(timing2.min)} | ${Helper_default.formatDuration(timing2.avg)} | ${Helper_default.formatDuration(timing2.max)} |`);
+          return [
+            "## Stage timings",
+            "",
+            "| Stage | Calls | Min | Avg | Max |",
+            "|---|---|---|---|---|",
+            ...rows
+          ].join("\n");
+        };
+        /**
+         * The reproduction, as a block to paste rather than a script to run.
+         *
+         * The bundle deliberately contains no executable — see `repro()` — so these are the same
+         * commands, here, where a scanner has nothing to quarantine and a reader has nothing to open.
+         */
+        this._reproduction = (page) => {
+          return [
+            "## Reproduce",
+            "",
+            "Unpack the bundle, then run this from the directory it unpacked into. Paste it, or save",
+            "it as a file and run that \u2014 the bundle ships no script of its own, so that nothing in it",
+            "is executable.",
+            "",
+            "```sh",
+            this.repro(page.repro).trimEnd(),
+            "```",
+            "",
+            "The input is generated, not captured. It reproduces every bug in the SHAPE of the",
+            "pipeline \u2014 joins, pivots, transformations, validation \u2014 and none that depend on what a",
+            "value was. The seed is derived from the bundle id, so it has no relation to the failing",
+            "run beyond being the same for whoever opens this bundle."
+          ].join("\n");
+        };
+        this._inventory = (sections) => {
+          const rows = sections.filter((section) => section.name !== "report").map((section) => `| ${section.name} | ${section.included ? "\u2705" : "\u2014"} | ${this._describe(section)} |`);
+          return [
+            "## In this bundle",
+            "",
+            "| Section | Present | Files |",
+            "|---|---|---|",
+            ...rows,
+            "",
+            "The configuration travels as authored \u2014 remora config names its credentials (`{ENV_VAR}`)",
+            "rather than holding them, so what is in `config/` is what runs. The log is scrubbed of",
+            "credential shapes (JWTs, access key ids, URL query strings), since a value that reached a",
+            "log line had already been resolved. No row of customer data is in this bundle."
+          ].join("\n");
+        };
+        /**
+         * What a section contributed, and what it left out. Past a handful of files the list stops
+         * being readable and becomes a count — the whole of `config/` is seventy file names, which
+         * tells a reader nothing the directory does not.
+         */
+        this._describe = (section) => {
+          const listed = section.files.length <= LISTED_FILES ? section.files.map((file) => `\`${file}\``).join(", ") : `${section.files.length} files under \`${section.files[0].split("/")[0]}/\``;
+          return [listed, section.reason].filter(Boolean).join(" \u2014 ") || "\u2014";
+        };
+        this._elapsed = (run) => {
+          const started = run.startedAt ? new Date(run.startedAt).getTime() : 0;
+          const finished = run.finishedAt ? new Date(run.finishedAt).getTime() : 0;
+          if (run.stats?.elapsedMS > 0)
+            return ` after ${Helper_default.formatDuration(run.stats.elapsedMS)}`;
+          if (started && finished)
+            return ` after ${Helper_default.formatDuration(finished - started)}`;
+          return run.status === "started" ? " \u2014 never reported a result" : "";
+        };
+        this._count = (value) => value === void 0 || value === null || value < 0 ? "unknown" : String(value);
+        this._iso = (value) => {
+          const date2 = value instanceof Date ? value : new Date(value);
+          return isNaN(date2.getTime()) ? String(value) : date2.toISOString();
+        };
+      }
+    };
+    BugReportRenderer = new BugReportRendererClass();
+    BugReportRenderer_default = BugReportRenderer;
+  }
+});
+
 // ../../packages/engines/src/ops/OpsService.ts
 var MAX_HISTORY_LIMIT, DEFAULT_HISTORY_LIMIT, MAX_LISTED_RESOURCES, BYTES_PER_MB, OpsServiceClass, OpsService, OpsService_default;
 var init_OpsService = __esm({
@@ -53370,6 +54380,390 @@ var init_OpsService = __esm({
   }
 });
 
+// ../../packages/engines/src/ops/RunLogSlicer.ts
+var RECORD_HEAD, MAX_INPUT_CHARS, RunLogSlicerClass, RunLogSlicer, RunLogSlicer_default;
+var init_RunLogSlicer = __esm({
+  "../../packages/engines/src/ops/RunLogSlicer.ts"() {
+    init_src();
+    RECORD_HEAD = /^\[([^\]]+)\] \[([A-Z]+)\] ?/;
+    MAX_INPUT_CHARS = 16e6;
+    RunLogSlicerClass = class {
+      constructor() {
+        /**
+         * The records belonging to one run, oldest first.
+         *
+         * A record is kept when it carries the run id OR falls inside the window. With no `to` — a run
+         * whose process died before it could record one — the window stays open to the end of the file
+         * and `maxRecords` is what bounds the answer, which is the honest shape of "we do not know when
+         * this stopped": take the tail of what followed the start.
+         *
+         * With neither a run id nor a `from`, every record matches and the result is the tail of the
+         * file. That is the degraded bundle, where there is no run history to slice by.
+         */
+        this.slice = (request) => {
+          Affirm_default(request, "Missing required parameter request");
+          Affirm_default(request.maxRecords > 0, "Log slice maxRecords must be greater than zero");
+          const records = this._parse(this._bound(request.text));
+          const matched = records.filter((record) => this._matches(record, request));
+          const kept = matched.slice(-request.maxRecords);
+          return {
+            text: kept.map((record) => record.text).join("\n"),
+            kept: kept.length,
+            scanned: records.length,
+            dropped: matched.length - kept.length,
+            errors: kept.filter((record) => record.level === "ERROR").map((record) => record.text)
+          };
+        };
+        /** The tail of the text, so a file larger than the cap is read from its most recent end. */
+        this._bound = (text) => {
+          if (!text) return "";
+          return text.length <= MAX_INPUT_CHARS ? text : text.slice(-MAX_INPUT_CHARS);
+        };
+        /**
+         * Lines folded back into records. A continuation line belongs to the record above it; lines
+         * before the first head — the tail cut above can produce them — are dropped, since they belong
+         * to a record whose timestamp was cut off with it.
+         */
+        this._parse = (text) => {
+          const records = [];
+          for (const line of text.split("\n")) {
+            const head = RECORD_HEAD.exec(line);
+            if (!head) {
+              if (records.length) records[records.length - 1].text += `
+${line}`;
+              continue;
+            }
+            const at3 = new Date(head[1]);
+            records.push({ at: isNaN(at3.getTime()) ? null : at3, level: head[2], text: line });
+          }
+          return records;
+        };
+        this._matches = (record, request) => {
+          if (request.runId && record.text.includes(request.runId))
+            return true;
+          if (!request.from)
+            return true;
+          if (!record.at)
+            return false;
+          return record.at >= request.from && (!request.to || record.at <= request.to);
+        };
+      }
+    };
+    RunLogSlicer = new RunLogSlicerClass();
+    RunLogSlicer_default = RunLogSlicer;
+  }
+});
+
+// ../../packages/engines/src/ops/BugReportService.ts
+var import_fs20, import_os2, import_path18, BUG_REPORT_SCHEMA_VERSION, MAX_RUN_LOG_RECORDS, MAX_TAIL_LOG_RECORDS, REPRO_RECORDS, SEED_LENGTH, CONFIG_EXTENSIONS, BEHAVIOURAL_VARIABLES, BugReportServiceClass, BugReportService;
+var init_BugReportService = __esm({
+  "../../packages/engines/src/ops/BugReportService.ts"() {
+    import_fs20 = __toESM(require("fs"), 1);
+    import_os2 = __toESM(require("os"), 1);
+    import_path18 = __toESM(require("path"), 1);
+    init_src4();
+    init_src3();
+    init_src();
+    init_src6();
+    init_src2();
+    init_LocalUsageDB();
+    init_UsageManager();
+    init_BugReportBundle();
+    init_BugReportRenderer();
+    init_OpsService();
+    init_RunLogSlicer();
+    BUG_REPORT_SCHEMA_VERSION = 1;
+    MAX_RUN_LOG_RECORDS = 5e3;
+    MAX_TAIL_LOG_RECORDS = 500;
+    REPRO_RECORDS = 100;
+    SEED_LENGTH = 8;
+    CONFIG_EXTENSIONS = [".json"];
+    BEHAVIOURAL_VARIABLES = [
+      "NODE_ENV",
+      "REMORA_RUNTIME_CONTEXT",
+      "REMORA_DEBUG_MODE",
+      "REMORA_LOG_FORMAT",
+      "REMORA_MAX_WORKERS",
+      "REMORA_STATE_ENABLED",
+      "REMORA_STATE_INTERVAL_MS",
+      "REMORA_MASK_IN_DEV"
+    ];
+    BugReportServiceClass = class {
+      constructor() {
+        /**
+         * Collect a bundle and write it as a .zip, returning where it landed and what went into it.
+         *
+         * @param request which run, which project, where to write. Every field has a default.
+         */
+        this.collect = (request = {}) => {
+          const bundle = new BugReportBundle_default();
+          const bundleId = Helper_default.uuid();
+          const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+          const projectPath = request.projectPath ?? Environment_default._localPath ?? "";
+          const inspection = this._inspect(projectPath);
+          const run = this._findRun(request.runId, bundle);
+          const environment = this._environment(projectPath, inspection);
+          const repro = this._repro(bundleId, run, inspection);
+          bundle.collect("environment", () => bundle.add("environment", "environment.json", JSON.stringify(environment, null, 4)));
+          this._collectRun(bundle, run);
+          this._collectConfig(bundle, projectPath);
+          const log = this._collectLogs(bundle, run);
+          bundle.skip("profile", "Producer data profiles need a re-run: use --capture (not yet available).");
+          bundle.skip("data", "No customer data is collected at this redaction level.");
+          bundle.collect("report", () => bundle.add("report", "report.md", BugReportRenderer_default.report({
+            bundleId,
+            createdAt,
+            remoraVersion: Constants_default.cliVersion,
+            run,
+            environment,
+            log,
+            repro,
+            sections: bundle.sections()
+          })));
+          const manifest = this._manifest({ bundleId, createdAt, run, environment, bundle });
+          const outputPath = import_path18.default.resolve(request.outputPath || this._defaultOutputPath(run, environment, createdAt));
+          Affirm_default(import_fs20.default.existsSync(import_path18.default.dirname(outputPath)), `Missing output directory: ${import_path18.default.dirname(outputPath)}`);
+          return { path: outputPath, bytes: bundle.write(outputPath, manifest), manifest };
+        };
+        /**
+         * What is on disk, read leniently.
+         *
+         * `inspect()` and not the loaded `Environment`, even in a process that has one: the bundle has
+         * to describe the configuration as it is NOW, and a loaded environment cannot report the
+         * resources that failed to load — which are routinely the whole of the bug.
+         */
+        this._inspect = (projectPath) => {
+          try {
+            return Environment_default.inspect(projectPath);
+          } catch (error) {
+            Logger_default.warn(`Bug report could not read the project at "${projectPath}": ${Helper_default.asError(error).message}`);
+            return null;
+          }
+        };
+        /**
+         * The run to report on, from the local run history.
+         *
+         * Absence is an expected outcome, not a failure: `UsageManager.recordsLocally()` is false
+         * whenever `MONGO_URI` is set, so a customer on a database has no local history at all. The
+         * bundle degrades to configuration, environment and the tail of the log, and says so.
+         */
+        this._findRun = (runId, bundle) => {
+          let found = null;
+          bundle.collect("run", () => {
+            found = runId ? LocalUsageDB_default.list(1, (usage) => usage._id === runId)[0] : LocalUsageDB_default.list(1)[0];
+            if (found) return;
+            bundle.skip("run", runId ? `No run "${runId}" in the local run history.` : this._noHistoryReason());
+          });
+          return found;
+        };
+        this._noHistoryReason = () => UsageManager_default.recordsLocally() ? "No runs recorded yet in ./remora/.temp/usage." : "MONGO_URI is set, so runs are recorded in the database rather than in the local file this reads.";
+        this._collectRun = (bundle, run) => {
+          if (!run) return;
+          bundle.collect("run", () => bundle.add("run", "run.json", JSON.stringify(run, null, 4)));
+        };
+        /**
+         * The project configuration, as authored, under `config/`.
+         *
+         * Not rewritten on the way out: a remora configuration NAMES its credentials (`{PG_PASSWORD}`)
+         * rather than holding them, so what a reader finds in `config/` is what runs — which is the
+         * whole point of shipping it. A literal password in a source file is a mistake to fix in the
+         * project, and redacting it here would only hide it from whoever could.
+         *
+         * Built from `ConfigPackager` so the exclusions are the deployment archive's own — one place
+         * decides that `.temp`, logs and `.env` never travel, and the `.env` refusal there is what
+         * keeps the file that DOES hold values out of this — and then filtered down to the config
+         * files themselves, because an allow-list is the only safe rule for anything else in there.
+         */
+        this._collectConfig = (bundle, projectPath) => {
+          bundle.collect("config", () => {
+            const configDir = import_path18.default.join(projectPath, "remora");
+            if (!import_fs20.default.existsSync(configDir))
+              return bundle.skip("config", `No configuration directory at ${import_path18.default.resolve(configDir)} \u2014 run the command from the project root.`);
+            const entries = ConfigPackager_default.build(configDir).getEntries().filter((entry) => !entry.isDirectory);
+            const carried = entries.filter((entry) => CONFIG_EXTENSIONS.includes(import_path18.default.extname(entry.entryName).toLowerCase()));
+            for (const entry of carried)
+              bundle.add("config", `config/${entry.entryName}`, entry.getData());
+            const skipped = entries.length - carried.length;
+            if (skipped > 0)
+              bundle.skip("config", `${skipped} non-JSON file(s) in the project directory were left out: only configuration travels.`);
+          });
+        };
+        /**
+         * This run's slice of the log file, redacted.
+         *
+         * Sliced by run id AND by time window, because only the orchestrator's own lines carry the id;
+         * a driver or parser line is placed by its timestamp alone. With no run to bound it, the tail
+         * is packaged and labelled as the tail.
+         */
+        this._collectLogs = (bundle, run) => {
+          let slice = null;
+          bundle.collect("logs", () => {
+            const logPath = Logger_default.filePath();
+            if (!import_fs20.default.existsSync(logPath))
+              return bundle.skip("logs", `No log file at ${import_path18.default.resolve(logPath)}. File logging turns itself on at the first error; a run that never errored has none.`);
+            slice = RunLogSlicer_default.slice({
+              text: import_fs20.default.readFileSync(logPath, "utf8"),
+              runId: run?._id,
+              from: run?.startedAt ? new Date(run.startedAt) : void 0,
+              to: run?.finishedAt ? new Date(run.finishedAt) : void 0,
+              maxRecords: run ? MAX_RUN_LOG_RECORDS : MAX_TAIL_LOG_RECORDS
+            });
+            if (!slice.kept)
+              return bundle.skip("logs", `The log file holds ${slice.scanned} record(s), none of them from this run.`);
+            bundle.add("logs", "logs/remora.log", SecretRedactor_default.redactText(slice.text));
+            if (slice.dropped)
+              bundle.skip("logs", `${slice.dropped} older matching record(s) dropped: the ${slice.kept} most recent are here.`);
+            else if (!run)
+              bundle.skip("logs", `No run to slice by, so this is the last ${slice.kept} record(s) of the file.`);
+          });
+          return slice;
+        };
+        /** Versions, machine, Node runtime, environment-variable presence and the config as read. */
+        this._environment = (projectPath, inspection) => {
+          return {
+            remora: OpsService_default.status().worker,
+            platform: this._platform(),
+            node: this._node(),
+            variables: this._variables(),
+            config: this._config(projectPath, inspection)
+          };
+        };
+        /**
+         * The machine. Every field is a fact about the host, none of them about the data on it.
+         *
+         * Each one answers a question the other evidence cannot: the CPU model separates "slow on a
+         * small instance" from "slow", the host name ties a run to a container an operator is looking
+         * at, and the time zone is where a datetime that read correctly and wrote wrong comes from.
+         */
+        this._platform = () => ({
+          hostname: this._quietly(() => import_os2.default.hostname()),
+          platform: process.platform,
+          arch: process.arch,
+          osType: this._quietly(() => import_os2.default.type()),
+          release: import_os2.default.release(),
+          osVersion: this._quietly(() => import_os2.default.version()),
+          cpuCount: import_os2.default.cpus()?.length ?? 0,
+          cpuModel: import_os2.default.cpus()?.[0]?.model ?? null,
+          totalMemoryMB: Math.round(import_os2.default.totalmem() / (1024 * 1024)),
+          freeMemoryMB: Math.round(import_os2.default.freemem() / (1024 * 1024)),
+          heapLimitMB: Math.round(Runtime_default.getHeap().heapSizeMB),
+          timezone: this._quietly(() => Intl.DateTimeFormat().resolvedOptions().timeZone)
+        });
+        /** The Node runtime, and the handful of variables whose VALUE explains what remora did. */
+        this._node = () => {
+          const settings = {};
+          for (const name of BEHAVIOURAL_VARIABLES)
+            if (process.env[name]) settings[name] = process.env[name];
+          return {
+            version: process.version,
+            v8: process.versions?.v8 ?? null,
+            openssl: process.versions?.openssl ?? null,
+            zlib: process.versions?.zlib ?? null,
+            icu: process.versions?.icu ?? null,
+            settings
+          };
+        };
+        /**
+         * A host lookup that cannot fail the report. `os.version()` and the ICU time zone are the two
+         * that vary by platform and build, and a missing one is worth less than the bundle it would
+         * otherwise take down.
+         */
+        this._quietly = (read) => {
+          try {
+            return read() ?? null;
+          } catch {
+            return null;
+          }
+        };
+        /**
+         * Which variables are SET here, never what they hold. "Is `REMORA_MAX_WORKERS` set on that
+         * machine" is most of what anyone needs, and it is answerable without a secret in a ticket.
+         */
+        this._variables = () => {
+          const present = {};
+          for (const name of ENVIRONMENT_VARIABLES)
+            present[name] = !!process.env[name];
+          return present;
+        };
+        this._config = (projectPath, inspection) => {
+          const env2 = inspection?.env;
+          return {
+            path: import_path18.default.resolve(projectPath || "."),
+            project: inspection?.projectName ?? null,
+            signature: this._signature(projectPath),
+            loaded: !!inspection,
+            counts: {
+              sources: env2?.sources?.length ?? 0,
+              producers: env2?.producers?.length ?? 0,
+              consumers: env2?.consumers?.length ?? 0,
+              codeSets: env2?.codeSets?.length ?? 0,
+              schemas: env2?.schemas?.length ?? 0
+            },
+            problems: inspection?.problems ?? [],
+            sources: (env2?.sources ?? []).map((source) => ({
+              name: source.name,
+              engine: source.engine,
+              authMethod: source.authentication?.method ?? null
+            })),
+            producers: (env2?.producers ?? []).map((producer) => ({
+              name: producer.name,
+              source: producer.source,
+              dimensionCount: producer.dimensions?.length ?? 0
+            })),
+            consumers: (env2?.consumers ?? []).map((consumer) => ({
+              name: consumer.name,
+              producers: (consumer.producers ?? []).map((x2) => x2.name),
+              outputs: (consumer.outputs ?? []).map((output) => output.trigger ? `${output.format} (${output.trigger.type} ${output.trigger.value ?? ""})`.trim() : `${output.format}`)
+            }))
+          };
+        };
+        this._signature = (projectPath) => {
+          try {
+            return Environment_default.configHash(projectPath)?.slice(0, 12) ?? null;
+          } catch {
+            return null;
+          }
+        };
+        /**
+         * The repro the bundle ships with.
+         *
+         * A post-mortem has no recorded input, so the seed comes from the bundle id: it is unrelated to
+         * the failing run and the manifest says so. A runnable wrong-data case still beats no case —
+         * it reproduces everything about the pipeline's shape, which is where most bugs live.
+         */
+        this._repro = (bundleId, run, inspection) => ({
+          consumer: run?.consumer ?? inspection?.env?.consumers?.[0]?.name ?? null,
+          seed: bundleId.replace(/-/g, "").slice(0, SEED_LENGTH),
+          records: REPRO_RECORDS,
+          syntheticData: true
+        });
+        this._manifest = (args) => ({
+          schemaVersion: BUG_REPORT_SCHEMA_VERSION,
+          bundleId: args.bundleId,
+          createdAt: args.createdAt,
+          redaction: "no-data",
+          remoraVersion: Constants_default.cliVersion,
+          runId: args.run?._id ?? null,
+          consumer: args.run?.consumer ?? null,
+          project: args.environment.config.project,
+          configLoaded: args.environment.config.loaded,
+          sections: args.bundle.sections(),
+          files: args.bundle.files()
+        });
+        /** `remora-report-<consumer>-<runId>.zip`, or the project and a timestamp when there is no run. */
+        this._defaultOutputPath = (run, environment, createdAt) => {
+          const subject = this._slug(run?.consumer ?? environment.config.project ?? "project");
+          const discriminator = run?._id ?? createdAt.replace(/[:.]/g, "-");
+          return `./remora-report-${subject}-${this._slug(discriminator)}.zip`;
+        };
+        /** A name safe on every file system this runs on, and readable afterwards. */
+        this._slug = (value) => value.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 60) || "report";
+      }
+    };
+    BugReportService = new BugReportServiceClass();
+  }
+});
+
 // ../../packages/engines/src/ops/OpsHeartbeat.ts
 var DEFAULT_INTERVAL_MS, MIN_INTERVAL_MS, MAX_INTERVAL_MS, OpsHeartbeatClass, OpsHeartbeat;
 var init_OpsHeartbeat = __esm({
@@ -53441,440 +54835,11 @@ var init_OpsHeartbeat = __esm({
   }
 });
 
-// ../../packages/engines/src/usage/LocalUsageDB.ts
-var import_fs17, import_path16, COLUMNS, CLI_DB_FOLDER, CLI_DB_FILE, CLI_DB_PATH, MAX_USAGE_ROWS, MAX_LISTED_ROWS, EXECUTED_BY_SCHEMA, EXECUTOR_OPERATION_SCHEMA, STATS_SCHEMA, COLUMN_SCHEMAS, LocalUsageDBClass, LocalUsageDB, LocalUsageDB_default;
-var init_LocalUsageDB = __esm({
-  "../../packages/engines/src/usage/LocalUsageDB.ts"() {
-    init_src();
-    import_fs17 = require("fs");
-    import_path16 = require("path");
-    COLUMNS = [
-      "_id",
-      "consumer",
-      "executedBy",
-      "startedAt",
-      "finishedAt",
-      "itemsCount",
-      "invokedBy",
-      "status",
-      "error",
-      "stats",
-      // Appended last on purpose: rows written before this column existed still decode positionally.
-      "engineVersion"
-    ];
-    CLI_DB_FOLDER = "./remora/.temp/usage";
-    CLI_DB_FILE = "remora_usage.csv";
-    CLI_DB_PATH = (0, import_path16.join)(CLI_DB_FOLDER, CLI_DB_FILE);
-    MAX_USAGE_ROWS = 1e4;
-    MAX_LISTED_ROWS = 500;
-    EXECUTED_BY_SCHEMA = {
-      _id: "string",
-      name: "string",
-      type: "string"
-    };
-    EXECUTOR_OPERATION_SCHEMA = {
-      elapsedMS: ["number"],
-      min: "number",
-      max: "number",
-      avg: "number"
-    };
-    STATS_SCHEMA = {
-      executionId: "string",
-      resultUri: "string",
-      elapsedMS: "number",
-      inputCount: "number",
-      outputCount: "number",
-      cycles: "number",
-      workerCount: "number",
-      operations: {
-        "*": EXECUTOR_OPERATION_SCHEMA
-      }
-    };
-    COLUMN_SCHEMAS = {
-      _id: "string",
-      consumer: "string",
-      executedBy: EXECUTED_BY_SCHEMA,
-      startedAt: "date",
-      finishedAt: "date",
-      itemsCount: "number",
-      invokedBy: "string",
-      status: "string",
-      error: "string",
-      stats: STATS_SCHEMA,
-      engineVersion: "string"
-    };
-    LocalUsageDBClass = class {
-      constructor() {
-        this._handleError = (action, error) => {
-          console.error(`LocalUsageDB ${action} failed:`, error);
-        };
-        this._splitSerialized = (value, separator) => {
-          if (!value)
-            return [];
-          const parts = [];
-          let current = "";
-          let quoteOpen = false;
-          let curlyDepth = 0;
-          let squareDepth = 0;
-          for (let index = 0; index < value.length; index++) {
-            const char = value[index];
-            const next = value[index + 1];
-            if (char === '"') {
-              current += char;
-              if (quoteOpen && next === '"') {
-                current += next;
-                index++;
-                continue;
-              }
-              quoteOpen = !quoteOpen;
-              continue;
-            }
-            if (!quoteOpen) {
-              if (char === "{")
-                curlyDepth++;
-              else if (char === "}")
-                curlyDepth--;
-              else if (char === "[")
-                squareDepth++;
-              else if (char === "]")
-                squareDepth--;
-              else if (char === separator && curlyDepth === 0 && squareDepth === 0) {
-                parts.push(current);
-                current = "";
-                continue;
-              }
-            }
-            current += char;
-          }
-          parts.push(current);
-          return parts;
-        };
-        this._splitKeyValue = (value) => {
-          let quoteOpen = false;
-          let curlyDepth = 0;
-          let squareDepth = 0;
-          for (let index = 0; index < value.length; index++) {
-            const char = value[index];
-            const next = value[index + 1];
-            if (char === '"') {
-              if (quoteOpen && next === '"') {
-                index++;
-                continue;
-              }
-              quoteOpen = !quoteOpen;
-              continue;
-            }
-            if (!quoteOpen) {
-              if (char === "{")
-                curlyDepth++;
-              else if (char === "}")
-                curlyDepth--;
-              else if (char === "[")
-                squareDepth++;
-              else if (char === "]")
-                squareDepth--;
-              else if (char === ":" && curlyDepth === 0 && squareDepth === 0)
-                return [value.slice(0, index), value.slice(index + 1)];
-            }
-          }
-          return [value, ""];
-        };
-        this._decodeString = (value) => {
-          if (!value)
-            return "";
-          if (value.startsWith('"') && value.endsWith('"'))
-            return value.slice(1, -1).replaceAll('""', '"');
-          return value;
-        };
-        this._decodeValue = (value, schema) => {
-          if (!value)
-            return null;
-          if (value.startsWith("{") && value.endsWith("}")) {
-            const objectSchema = schema && !Array.isArray(schema) && typeof schema === "object" ? schema : {};
-            const dynamicSchema = objectSchema["*"];
-            const serializedEntries = this._splitSerialized(value.slice(1, -1), ";");
-            const decodedObject = {};
-            serializedEntries.forEach((entry) => {
-              const [rawKey, rawValue] = this._splitKeyValue(entry);
-              const key = this._decodeString(rawKey);
-              decodedObject[key] = this._decodeValue(rawValue, objectSchema[key] ?? dynamicSchema);
-            });
-            return decodedObject;
-          }
-          if (value.startsWith("[") && value.endsWith("]")) {
-            const serializedItems = this._splitSerialized(value.slice(1, -1), ";");
-            const itemSchema = Array.isArray(schema) ? schema[0] : void 0;
-            return serializedItems.map((item) => this._decodeValue(item, itemSchema));
-          }
-          const decodedString = this._decodeString(value);
-          if (schema === "number")
-            return Number(decodedString);
-          if (schema === "date")
-            return decodedString ? new Date(decodedString) : null;
-          return decodedString;
-        };
-        this._encodeValue = (value) => {
-          if (value === null || value === void 0)
-            return "";
-          else if (value instanceof Date)
-            return `"${value.toISOString().replaceAll('"', '""')}"`;
-          else if (Array.isArray(value))
-            return `[${value.map((item) => this._encodeValue(item)).join(";")}]`;
-          else if (typeof value === "object")
-            return `{${Object.keys(value).map((key) => `${this._encodeValue(key)}:${this._encodeValue(value[key])}`).join(";")}}`;
-          else
-            return `"${(value ?? "").toString().replaceAll('"', '""')}"`;
-        };
-        this._toLine = (usage) => {
-          return COLUMNS.map((column) => this._encodeValue(usage[column])).join(",");
-        };
-        this._fromLine = (line) => {
-          const values = this._splitSerialized(line, ",");
-          const usage = {};
-          COLUMNS.forEach((column, index) => {
-            usage[column] = this._decodeValue(values[index] ?? "", COLUMN_SCHEMAS[column]);
-          });
-          return usage;
-        };
-        this._getRows = () => {
-          const lines = (0, import_fs17.readFileSync)(CLI_DB_PATH, "utf8").split("\n").filter(Boolean);
-          lines.shift();
-          return lines;
-        };
-        this._writeRows = (rows) => {
-          const trimmedRows = rows.slice(-MAX_USAGE_ROWS);
-          (0, import_fs17.writeFileSync)(CLI_DB_PATH, `${[COLUMNS.join(","), ...trimmedRows].join("\n")}
-`);
-        };
-        this.init = () => {
-          try {
-            if (!(0, import_fs17.existsSync)(CLI_DB_FOLDER))
-              (0, import_fs17.mkdirSync)(CLI_DB_FOLDER, { recursive: true });
-            if (!(0, import_fs17.existsSync)(CLI_DB_PATH))
-              (0, import_fs17.writeFileSync)(CLI_DB_PATH, `${COLUMNS.join(",")}
-`);
-            this._writeRows(this._getRows());
-          } catch (error) {
-            this._handleError("init", error);
-          }
-        };
-        this.insert = (usage) => {
-          try {
-            this.init();
-            this._writeRows([...this._getRows(), this._toLine(usage)]);
-          } catch (error) {
-            this._handleError("insert", error);
-          }
-        };
-        /**
-         * The recorded runs, newest first — the newest `limit` of the rows `keep` accepts.
-         *
-         * Decoded from the end and stopped as soon as that many are held: a reader wants the recent
-         * executions, and decoding ten thousand rows to show ten of them is work nobody asked for.
-         *
-         * `keep` is applied BEFORE the limit, which is the only way "the newest N runs of this kind" can
-         * mean it: filtering afterwards lets the rows a caller does not want displace the ones it does,
-         * so one sample recorded here would silently push a real run out of a history someone is reading.
-         *
-         * Never throws. A missing file reads as no history, and so does a half-written one — this store is
-         * appended to while it is being read, so failing on that would make it unreadable during a run.
-         */
-        this.list = (limit = MAX_LISTED_ROWS, keep) => {
-          try {
-            if (!(0, import_fs17.existsSync)(CLI_DB_PATH))
-              return [];
-            const rows = this._getRows();
-            const wanted = Math.max(1, limit);
-            const found = [];
-            for (let index = rows.length - 1; index >= 0 && found.length < wanted; index--) {
-              const usage = this._fromLine(rows[index]);
-              if (!keep || keep(usage)) found.push(usage);
-            }
-            return found;
-          } catch (error) {
-            this._handleError("list", error);
-            return [];
-          }
-        };
-        /**
-         * A token that changes whenever the store does, cheap enough to poll: a preview watching for a
-         * finished run must not decode the whole file once a second to notice one.
-         */
-        this.signature = () => {
-          try {
-            if (!(0, import_fs17.existsSync)(CLI_DB_PATH))
-              return "";
-            const stats = (0, import_fs17.statSync)(CLI_DB_PATH);
-            return `${stats.mtimeMs}:${stats.size}`;
-          } catch (error) {
-            this._handleError("signature", error);
-            return "";
-          }
-        };
-        this.update = (update) => {
-          try {
-            Affirm_default(update?._id, "Invalid usage update _id");
-            this.init();
-            const updatedLines = this._getRows().map((line) => {
-              const current = this._fromLine(line);
-              if (current._id !== update._id) return line;
-              return this._toLine({ ...current, ...update });
-            });
-            this._writeRows(updatedLines);
-          } catch (error) {
-            this._handleError("update", error);
-          }
-        };
-      }
-    };
-    LocalUsageDB = new LocalUsageDBClass();
-    LocalUsageDB_default = LocalUsageDB;
-  }
-});
-
-// ../../packages/engines/src/usage/UsageManager.ts
-var MAX_RECORDED_OPERATIONS, UsageManagerClass, UsageManager, UsageManager_default;
-var init_UsageManager = __esm({
-  "../../packages/engines/src/usage/UsageManager.ts"() {
-    init_src();
-    init_src3();
-    init_src();
-    init_src4();
-    init_src9();
-    init_src6();
-    init_src6();
-    init_src2();
-    init_RunRegistry();
-    init_LocalUsageDB();
-    MAX_RECORDED_OPERATIONS = 40;
-    UsageManagerClass = class {
-      constructor() {
-        this._shouldSkipDb = () => Helper_default.isDev() || !process.env.MONGO_URI;
-        this._shouldLogCLI = () => process.env.REMORA_RUNTIME_CONTEXT === "cli";
-        /**
-         * Whether this runtime keeps its execution records in the local file rather than in the usage
-         * collection. Public because a READER has to make the same decision the writer just made — two
-         * answers to "where are the runs" is one answer too many.
-         */
-        this.recordsLocally = () => this._shouldSkipDb() && this._shouldLogCLI();
-        this.startUsage = (consumer, details) => {
-          const { user, invokedBy } = details;
-          const newUsage = {
-            _id: Helper_default.uuid(),
-            consumer: consumer.name,
-            engineVersion: Constants_default.cliVersion,
-            startedAt: DSTE_default.now(),
-            executedBy: user,
-            itemsCount: -1,
-            status: "started",
-            invokedBy: invokedBy ?? "UNKNOWN",
-            _signature: "",
-            stats: null
-          };
-          RunRegistry_default.start({
-            executionId: newUsage._id,
-            consumer: newUsage.consumer,
-            invokedBy: newUsage.invokedBy,
-            userType: user?.type ?? "UNKNOWN",
-            startedAt: newUsage.startedAt
-          });
-          if (this._shouldSkipDb()) {
-            if (this._shouldLogCLI())
-              LocalUsageDB_default.insert(newUsage);
-            return { usageId: newUsage._id, usage: Promise.resolve(newUsage) };
-          }
-          const updateRes = DatabaseEngine_default.upsert(Settings_default.db.collections.usage, newUsage._id, newUsage);
-          return { usageId: newUsage._id, usage: updateRes };
-        };
-        this.endUsage = (usageId, itemsCount, stats) => {
-          const update = {
-            itemsCount,
-            status: "success",
-            finishedAt: DSTE_default.now(),
-            stats
-          };
-          this._emitRunRecord(usageId, "success", stats, null);
-          if (this._shouldSkipDb()) {
-            if (this._shouldLogCLI())
-              LocalUsageDB_default.update({ ...update, _id: usageId });
-            return { usageId: null, usage: Promise.resolve(update) };
-          }
-          const updateRes = DatabaseEngine_default.upsert(Settings_default.db.collections.usage, usageId, update);
-          return { usageId, usage: updateRes };
-        };
-        this.failUsage = (usageId, error) => {
-          const update = {
-            status: "failed",
-            error,
-            finishedAt: DSTE_default.now()
-          };
-          this._emitRunRecord(usageId, "failed", null, error);
-          if (this._shouldSkipDb()) {
-            if (this._shouldLogCLI())
-              LocalUsageDB_default.update({ ...update, _id: usageId });
-            return { usageId: null, usage: Promise.resolve(update) };
-          }
-          const updateRes = DatabaseEngine_default.upsert(Settings_default.db.collections.usage, usageId, update);
-          return { usageId, usage: updateRes };
-        };
-        /**
-         * Close out the in-flight entry and write one structured record for the finished run.
-         *
-         * This is the cheapest useful thing in the whole ops surface: the executor already hands us the
-         * complete result, so a single hook makes every run queryable in the log pipeline without a
-         * database. Never throws — reporting on a run must not be able to fail the run.
-         */
-        this._emitRunRecord = (usageId, status, stats, error) => {
-          Affirm_default(usageId, "Missing usage id");
-          try {
-            const run = RunRegistry_default.finish(usageId);
-            const record = {
-              executionId: usageId,
-              consumer: run?.consumer ?? null,
-              engineVersion: Constants_default.cliVersion,
-              project: Environment_default._env ? Environment_default.getProjectName() : null,
-              invokedBy: run?.invokedBy ?? null,
-              userType: run?.userType ?? null,
-              status,
-              startedAt: run?.startedAt?.toISOString() ?? null,
-              elapsedMS: stats?.elapsedMS ?? (run ? DSTE_default.now().getTime() - run.startedAt.getTime() : -1),
-              inputCount: stats?.inputCount ?? -1,
-              outputCount: stats?.outputCount ?? -1,
-              cycles: stats?.cycles ?? -1,
-              workerCount: stats?.workerCount ?? -1,
-              operations: this._summarizeOperations(stats),
-              error: error ?? null
-            };
-            StateEmitter_default.emit("run", record);
-          } catch {
-          }
-        };
-        /**
-         * Keep only min/max/avg per stage. The raw `elapsedMS` array holds one entry per worker chunk
-         * and can run to thousands of numbers on a large run — useless in a log line and unbounded.
-         */
-        this._summarizeOperations = (stats) => {
-          const operations = {};
-          if (!stats?.operations)
-            return operations;
-          for (const name of Object.keys(stats.operations).slice(0, MAX_RECORDED_OPERATIONS)) {
-            const operation2 = stats.operations[name];
-            operations[name] = { min: operation2.min, max: operation2.max, avg: operation2.avg };
-          }
-          return operations;
-        };
-      }
-    };
-    UsageManager = new UsageManagerClass();
-    UsageManager_default = UsageManager;
-  }
-});
-
 // ../../packages/engines/src/ops/RunOverlay.ts
-var import_crypto7, MAX_RUNS, MAX_OPERATIONS, RunOverlayClass, RunOverlay;
+var import_crypto8, MAX_RUNS, MAX_OPERATIONS, RunOverlayClass, RunOverlay;
 var init_RunOverlay = __esm({
   "../../packages/engines/src/ops/RunOverlay.ts"() {
-    import_crypto7 = __toESM(require("crypto"), 1);
+    import_crypto8 = __toESM(require("crypto"), 1);
     init_src();
     init_LineageEngine();
     init_LocalUsageDB();
@@ -53928,7 +54893,7 @@ var init_RunOverlay = __esm({
          * finish action writes runs of its own, so a narrower token would miss a transition the graph
          * exists to show.
          */
-        this._token = (overlay) => import_crypto7.default.createHash("sha256").update(JSON.stringify(overlay)).digest("hex");
+        this._token = (overlay) => import_crypto8.default.createHash("sha256").update(JSON.stringify(overlay)).digest("hex");
         this._run = (stat) => {
           const startedAt = this._iso(stat.startedAt);
           return {
@@ -54210,12 +55175,12 @@ var init_LookupRegistry = __esm({
 });
 
 // ../../packages/engines/src/transform/LookupKey.ts
-var import_crypto8, DELIMITER, idFor, LookupKey, LookupKey_default;
+var import_crypto9, DELIMITER, idFor, LookupKey, LookupKey_default;
 var init_LookupKey = __esm({
   "../../packages/engines/src/transform/LookupKey.ts"() {
-    import_crypto8 = __toESM(require("crypto"), 1);
+    import_crypto9 = __toESM(require("crypto"), 1);
     DELIMITER = String.fromCharCode(0);
-    idFor = (ref) => import_crypto8.default.createHash("sha1").update([ref.consumer, ref.key, ref.value].join(DELIMITER)).digest("hex").slice(0, 16);
+    idFor = (ref) => import_crypto9.default.createHash("sha1").update([ref.consumer, ref.key, ref.value].join(DELIMITER)).digest("hex").slice(0, 16);
     LookupKey = { idFor };
     LookupKey_default = LookupKey;
   }
@@ -54845,6 +55810,9 @@ var init_src10 = __esm({
     init_RequestExecutor();
     init_RequestValidator();
     init_lineage();
+    init_BugReportService();
+    init_BugReportRenderer();
+    init_RunLogSlicer();
     init_OpsService();
     init_OpsHeartbeat();
     init_RunOverlay();
@@ -54960,10 +55928,11 @@ var init_OutputExecutor = __esm({
             const driver = await DriverFactory_default.instantiateDestination(destination);
             const destinationName = this._composeFileName(consumer, output, this._getExtension(output));
             Logger_default.info(`Exporting consumer "${consumer.name}" to "${output.exportDestination}" as ${output.format} (${destinationName}, ${splitFiles.length} file(s))`);
+            const header = this._composeHeader(output, fields);
             for (const { path: startingPath, label } of splitFiles) {
               const destinationPath = this.getCompletedPath(destinationName, label);
               if (output.format === internalFormat) {
-                results.push(await driver.move(startingPath, destinationPath));
+                results.push(await driver.move(startingPath, destinationPath, header));
               } else {
                 switch (output.format) {
                   case "CSV":
@@ -54971,16 +55940,17 @@ var init_OutputExecutor = __esm({
                       await driver.transformAndMove(startingPath, (line) => {
                         const parsed = JSON.parse(line);
                         return Object.keys(parsed).map((x2) => `"${parsed[x2]}"`).join(",");
-                      }, destinationPath)
+                      }, destinationPath, header)
                     );
                     break;
                   case "TXT": {
-                    const delimiter = output.delimiter ?? "	";
+                    const delimiter = this._getDelimiter(output);
                     results.push(
                       await driver.transformAndMove(
                         startingPath,
                         (line) => CSVParser_default.stringifyRow(CSVParser_default.parseRow(line, ","), delimiter),
-                        destinationPath
+                        destinationPath,
+                        header
                       )
                     );
                     break;
@@ -55019,6 +55989,25 @@ var init_OutputExecutor = __esm({
           resultList[0].res = resultList.every((res) => res.res);
           return resultList[0];
         };
+        /**
+         * The header line of a positional export: the visible field names, in column order, quoted and
+         * delimited exactly as the rows under them — so the header parses with the same reader the data
+         * does. Null for a JSON/API output, where a record already carries its own field names, and for
+         * an output that turns the header off.
+         *
+         * The names are the exported ones (`finalKey`, i.e. the alias where one is set), since a reader
+         * of the file has nothing else to match a column against.
+         */
+        this._composeHeader = (output, fields) => {
+          if (output.header === false) return null;
+          if (output.format !== "CSV" && output.format !== "TXT") return null;
+          const names = fields.filter((x2) => !x2.cField.hidden).map((x2) => x2.finalKey);
+          return CSVParser_default.stringifyRow(names, this._getDelimiter(output));
+        };
+        /** The delimiter the exported file is written with. Only TXT configures it; CSV is a comma. */
+        this._getDelimiter = (output) => {
+          return output.format === "TXT" ? output.delimiter ?? "	" : ",";
+        };
         this._getExtension = (output) => {
           return output.format === "CSV" ? "csv" : output.format === "JSON" ? "jsonl" : "txt";
         };
@@ -55039,13 +56028,13 @@ var init_OutputExecutor = __esm({
 });
 
 // ../../packages/executors/src/ConsumerExecutor.ts
-var import_path17, import_fs18, import_promises16, import_crypto9, LIMIT_SCAN_BYTES, NEWLINE_BYTE, ConsumerExecutorClass, ConsumerExecutor, ConsumerExecutor_default;
+var import_path19, import_fs21, import_promises16, import_crypto10, LIMIT_SCAN_BYTES, NEWLINE_BYTE, ConsumerExecutorClass, ConsumerExecutor, ConsumerExecutor_default;
 var init_ConsumerExecutor = __esm({
   "../../packages/executors/src/ConsumerExecutor.ts"() {
-    import_path17 = __toESM(require("path"));
-    import_fs18 = __toESM(require("fs"));
+    import_path19 = __toESM(require("path"));
+    import_fs21 = __toESM(require("fs"));
     import_promises16 = __toESM(require("fs/promises"));
-    import_crypto9 = __toESM(require("crypto"));
+    import_crypto10 = __toESM(require("crypto"));
     init_src10();
     init_src10();
     init_src10();
@@ -55059,11 +56048,11 @@ var init_ConsumerExecutor = __esm({
     ConsumerExecutorClass = class {
       constructor() {
         this._ensurePath = (pathUri) => {
-          const dir = import_path17.default.dirname(pathUri);
-          if (!import_fs18.default.existsSync(dir))
-            import_fs18.default.mkdirSync(dir, { recursive: true });
-          if (!import_fs18.default.existsSync(pathUri))
-            import_fs18.default.writeFileSync(pathUri, "");
+          const dir = import_path19.default.dirname(pathUri);
+          if (!import_fs21.default.existsSync(dir))
+            import_fs21.default.mkdirSync(dir, { recursive: true });
+          if (!import_fs21.default.existsSync(pathUri))
+            import_fs21.default.writeFileSync(pathUri, "");
         };
         /**
          * Shapes one parsed producer record into one consumer record, following a plan compiled once per
@@ -55184,8 +56173,8 @@ var init_ConsumerExecutor = __esm({
           if (lineCountFields.length === 0)
             return 0;
           const tempWorkPath = datasetPath + "_tmp";
-          const reader = import_fs18.default.createReadStream(datasetPath);
-          const writer = import_fs18.default.createWriteStream(tempWorkPath);
+          const reader = import_fs21.default.createReadStream(datasetPath);
+          const writer = import_fs21.default.createWriteStream(tempWorkPath);
           const waitForDrain = () => new Promise((resolve) => writer.once("drain", resolve));
           let workerIndex = 0;
           let currentWorker = executorResults[workerIndex] ?? null;
@@ -55274,14 +56263,14 @@ var init_ConsumerExecutor = __esm({
           }
         };
         this.processDistinct = async (datasetPath) => {
-          const reader = import_fs18.default.createReadStream(datasetPath);
+          const reader = import_fs21.default.createReadStream(datasetPath);
           const tempWorkPath = datasetPath + "_tmp";
-          const writer = import_fs18.default.createWriteStream(tempWorkPath);
+          const writer = import_fs21.default.createWriteStream(tempWorkPath);
           const waitForDrain = () => new Promise((resolve) => writer.once("drain", resolve));
           let newLineCount = 0;
           const seen = /* @__PURE__ */ new Set();
           for await (const line of readLines(reader)) {
-            const hash = import_crypto9.default.createHash("sha1").update(line).digest("base64");
+            const hash = import_crypto10.default.createHash("sha1").update(line).digest("base64");
             if (!seen.has(hash)) {
               seen.add(hash);
               if (!writer.write(line + "\n"))
@@ -55305,7 +56294,7 @@ var init_ConsumerExecutor = __esm({
           return newLineCount;
         };
         this.processDistinctOn = async (consumer, datasetPath) => {
-          const reader = import_fs18.default.createReadStream(datasetPath);
+          const reader = import_fs21.default.createReadStream(datasetPath);
           const { distinctOn } = consumer.options;
           const { keys, resolution } = distinctOn;
           const { strategy, orderBy, direction = "asc" } = resolution;
@@ -55326,7 +56315,7 @@ var init_ConsumerExecutor = __esm({
             }
           }
           const tempWorkPath = datasetPath + "_tmp";
-          const writer = import_fs18.default.createWriteStream(tempWorkPath);
+          const writer = import_fs21.default.createWriteStream(tempWorkPath);
           const waitForDrain = () => new Promise((resolve) => writer.once("drain", resolve));
           for (const { line } of winners.values()) {
             if (!writer.write(line + "\n"))
@@ -55356,7 +56345,7 @@ var init_ConsumerExecutor = __esm({
           if (!pivotValues) {
             pivotValues = [];
             const discoverySet = /* @__PURE__ */ new Set();
-            const discoverReader = import_fs18.default.createReadStream(datasetPath);
+            const discoverReader = import_fs21.default.createReadStream(datasetPath);
             for await (const line of readLines(discoverReader)) {
               const record = this._parseLine(line, internalRecordFormat, internalFields);
               const val = String(record[pivotColumn] ?? "");
@@ -55373,7 +56362,7 @@ var init_ConsumerExecutor = __esm({
             }
           }
           const groups = /* @__PURE__ */ new Map();
-          const reader = import_fs18.default.createReadStream(datasetPath);
+          const reader = import_fs21.default.createReadStream(datasetPath);
           for await (const line of readLines(reader)) {
             const record = this._parseLine(line, internalRecordFormat, internalFields);
             const compositeKey = rowKeys.map((k7) => String(record[k7] ?? "")).join("|");
@@ -55400,7 +56389,7 @@ var init_ConsumerExecutor = __esm({
           ];
           const outputPlan = OutputExecutor_default.compileOutput(consumer, pivotedFields);
           const tempWorkPath = datasetPath + "_tmp";
-          const writer = import_fs18.default.createWriteStream(tempWorkPath);
+          const writer = import_fs21.default.createWriteStream(tempWorkPath);
           const waitForDrain = () => new Promise((resolve) => writer.once("drain", resolve));
           let outputCount = 0;
           for (const { rowRecord, cells } of groups.values()) {
@@ -55493,7 +56482,7 @@ var init_ConsumerExecutor = __esm({
           for (const fieldKey of uniqueFieldKeys) {
             fieldValueSets.set(fieldKey, /* @__PURE__ */ new Set());
           }
-          const reader = import_fs18.default.createReadStream(datasetPath);
+          const reader = import_fs21.default.createReadStream(datasetPath);
           for await (const line of readLines(reader)) {
             rowCount++;
             if (checkDuplicateRows) {
@@ -55541,7 +56530,7 @@ var init_ConsumerExecutor = __esm({
 });
 
 // ../../packages/executors/src/ProducerExecutor.ts
-var import_path18, ProducerExecutorClass, ProducerExecutor, ProducerExecutor_default;
+var import_path20, ProducerExecutorClass, ProducerExecutor, ProducerExecutor_default;
 var init_ProducerExecutor = __esm({
   "../../packages/executors/src/ProducerExecutor.ts"() {
     init_src();
@@ -55549,7 +56538,7 @@ var init_ProducerExecutor = __esm({
     init_src4();
     init_src10();
     init_src10();
-    import_path18 = __toESM(require("path"));
+    import_path20 = __toESM(require("path"));
     init_src2();
     ProducerExecutorClass = class {
       constructor() {
@@ -55584,7 +56573,7 @@ var init_ProducerExecutor = __esm({
         this.compileLine = (dimensions, chunk) => {
           Affirm_default(dimensions, "Invalid producer dimensions");
           Affirm_default(chunk, "Invalid chunk");
-          return { fills: ProducerManager_default.compileFills(dimensions), sourceFilename: import_path18.default.basename(chunk.fileUri) };
+          return { fills: ProducerManager_default.compileFills(dimensions), sourceFilename: import_path20.default.basename(chunk.fileUri) };
         };
         /**
          * The record(s) one source line produces. Almost always exactly one — a producer with a group
@@ -55640,10 +56629,10 @@ var init_ExecutorPerformance = __esm({
 });
 
 // ../../packages/executors/src/ExecutorWriter.ts
-var fs23, ExecutorWriter, ExecutorWriter_default;
+var fs26, ExecutorWriter, ExecutorWriter_default;
 var init_ExecutorWriter = __esm({
   "../../packages/executors/src/ExecutorWriter.ts"() {
-    fs23 = __toESM(require("fs"));
+    fs26 = __toESM(require("fs"));
     init_src();
     init_src3();
     init_src10();
@@ -55695,7 +56684,7 @@ var init_ExecutorWriter = __esm({
           await this._route(pass, fields);
           if (pass.buckets.size === 0)
             return [{ path: sourcePath, label: this.UNSPLIT_LABEL }];
-          await fs23.promises.unlink(sourcePath);
+          await fs26.promises.unlink(sourcePath);
           return this._listFiles(pass);
         };
         /**
@@ -55703,7 +56692,7 @@ var init_ExecutorWriter = __esm({
          */
         this._route = async (pass, fields) => {
           const internalFormat = OutputExecutor_default._getInternalRecordFormat(pass.consumer);
-          const readStream = fs23.createReadStream(pass.sourcePath);
+          const readStream = fs26.createReadStream(pass.sourcePath);
           try {
             for await (const line of readLines(readStream)) {
               const bucket = this._bucketFor(line, pass, internalFormat, fields);
@@ -55807,7 +56796,7 @@ var init_ExecutorWriter = __esm({
           }
           if (pass.openStreams.length >= Constants_default.defaults.MAX_OPEN_SPLIT_STREAMS)
             await this._closeStream(pass.openStreams.shift());
-          bucket.stream = fs23.createWriteStream(this.getCompletedPath(pass.sourcePath, this._composeLabel(bucket, pass)), { flags: "a" });
+          bucket.stream = fs26.createWriteStream(this.getCompletedPath(pass.sourcePath, this._composeLabel(bucket, pass)), { flags: "a" });
           pass.openStreams.push(bucket);
           return bucket.stream;
         };
@@ -55914,19 +56903,19 @@ var init_ExecutorProgress2 = __esm({
 });
 
 // ../../packages/executors/src/OrchestratorHelper.ts
-var import_os2, import_path19, OrchestratorHelper, OrchestratorHelper_default;
+var import_os3, import_path21, OrchestratorHelper, OrchestratorHelper_default;
 var init_OrchestratorHelper = __esm({
   "../../packages/executors/src/OrchestratorHelper.ts"() {
     init_src();
     init_src6();
-    import_os2 = __toESM(require("os"));
+    import_os3 = __toESM(require("os"));
     init_src4();
-    import_path19 = __toESM(require("path"));
+    import_path21 = __toESM(require("path"));
     init_src3();
     OrchestratorHelper = {
       getMemoryUsage: () => {
         const processMemory = process.memoryUsage();
-        const freeSystemMemory = import_os2.default.freemem();
+        const freeSystemMemory = import_os3.default.freemem();
         return {
           /**
            * resident set size (heap + code + stack)
@@ -56013,14 +57002,14 @@ var init_OrchestratorHelper = __esm({
       getPhysicalWorkerPath: () => {
         const currentDir = __dirname;
         if (ProcessENVManager_default.getEnvVariable("NODE_ENV") === "dev" || ProcessENVManager_default.getEnvVariable("NODE_ENV") === "development")
-          return import_path19.default.resolve("./.build/workers");
+          return import_path21.default.resolve("./.build/workers");
         const forcedPath = ProcessENVManager_default.getEnvVariable("REMORA_WORKERS_PATH");
         if (forcedPath && forcedPath.length > 0)
-          return import_path19.default.join(__dirname, forcedPath);
+          return import_path21.default.join(__dirname, forcedPath);
         if (!currentDir.includes(".build")) {
-          return import_path19.default.join(__dirname, "../workers");
+          return import_path21.default.join(__dirname, "../workers");
         } else {
-          return import_path19.default.resolve("./.build/workers");
+          return import_path21.default.resolve("./.build/workers");
         }
       },
       /**
@@ -56032,8 +57021,8 @@ var init_OrchestratorHelper = __esm({
        * fix (a 4GB box previously got `cpus - 1` workers, each permitted 2000MB).
        */
       getParallelWorkerCount: () => {
-        const cpuBoundWorkers = Math.max(1, Math.floor(import_os2.default.cpus().length * 0.7));
-        const totalMemoryMB = Math.floor(import_os2.default.totalmem() / (1024 * 1024));
+        const cpuBoundWorkers = Math.max(1, Math.floor(import_os3.default.cpus().length * 0.7));
+        const totalMemoryMB = Math.floor(import_os3.default.totalmem() / (1024 * 1024));
         const reservedMemoryMB = Constants_default.defaults.MIN_RUNTIME_HEAP_MB * 2;
         const availableMemoryForWorkersMB = Math.max(Constants_default.defaults.MIN_RUNTIME_HEAP_MB, totalMemoryMB - reservedMemoryMB);
         const memoryBoundWorkers = Math.max(1, Math.floor(availableMemoryForWorkersMB / Constants_default.defaults.MIN_RUNTIME_HEAP_MB));
@@ -56085,12 +57074,12 @@ var init_OrchestratorHelper = __esm({
 });
 
 // ../../packages/executors/src/LookupResolver.ts
-var import_fs20, import_promises17, import_path20, LookupResolverClass, LookupResolver, LookupResolver_default;
+var import_fs23, import_promises17, import_path22, LookupResolverClass, LookupResolver, LookupResolver_default;
 var init_LookupResolver = __esm({
   "../../packages/executors/src/LookupResolver.ts"() {
-    import_fs20 = __toESM(require("fs"));
+    import_fs23 = __toESM(require("fs"));
     import_promises17 = __toESM(require("fs/promises"));
-    import_path20 = __toESM(require("path"));
+    import_path22 = __toESM(require("path"));
     init_src();
     init_src3();
     init_src4();
@@ -56130,7 +57119,7 @@ var init_LookupResolver = __esm({
             }
             ExecutorScope_default.ensurePath(outPath);
             await import_promises17.default.writeFile(outPath, JSON.stringify(this.cache.get(id)));
-            manifest.push({ id, consumer: ref.consumer, key: ref.key, value: ref.value, path: import_path20.default.resolve(outPath) });
+            manifest.push({ id, consumer: ref.consumer, key: ref.key, value: ref.value, path: import_path22.default.resolve(outPath) });
           }
           for (const capturePath of captureByConsumer.values())
             await import_promises17.default.rm(capturePath, { force: true });
@@ -56159,7 +57148,7 @@ var init_LookupResolver = __esm({
           const dict = {};
           let rowsRead = 0;
           let warnedDup = false;
-          for await (const line of readLines(import_fs20.default.createReadStream(capturePath))) {
+          for await (const line of readLines(import_fs23.default.createReadStream(capturePath))) {
             if (!line.length) continue;
             rowsRead++;
             Affirm_default(rowsRead <= Constants_default.defaults.MAX_LOOKUP_ROWS, `code_lookup table from consumer "${ref.consumer}" exceeds MAX_LOOKUP_ROWS (${Constants_default.defaults.MAX_LOOKUP_ROWS})`);
@@ -56179,8 +57168,8 @@ var init_LookupResolver = __esm({
           return JSON.parse(line);
         };
         this.getCapturePath = (scope, consumerName) => {
-          const dir = import_path20.default.dirname(ExecutorScope_default.getLookupPath(scope, "x"));
-          return import_path20.default.join(dir, `${consumerName}.capture`);
+          const dir = import_path22.default.dirname(ExecutorScope_default.getLookupPath(scope, "x"));
+          return import_path22.default.join(dir, `${consumerName}.capture`);
         };
         this.dedupe = (refs) => {
           const byId = /* @__PURE__ */ new Map();
@@ -56202,12 +57191,12 @@ var init_LookupResolver = __esm({
 });
 
 // ../../packages/executors/src/ConsumerInputResolver.ts
-var import_fs21, import_promises18, import_path21, ConsumerInputResolverClass, ConsumerInputResolver, ConsumerInputResolver_default;
+var import_fs24, import_promises18, import_path23, ConsumerInputResolverClass, ConsumerInputResolver, ConsumerInputResolver_default;
 var init_ConsumerInputResolver = __esm({
   "../../packages/executors/src/ConsumerInputResolver.ts"() {
-    import_fs21 = __toESM(require("fs"));
+    import_fs24 = __toESM(require("fs"));
     import_promises18 = __toESM(require("fs/promises"));
-    import_path21 = __toESM(require("path"));
+    import_path23 = __toESM(require("path"));
     init_src();
     init_src3();
     init_src4();
@@ -56230,7 +57219,7 @@ var init_ConsumerInputResolver = __esm({
           Affirm_default(stack.length <= Constants_default.defaults.MAX_CONSUMER_INPUT_DEPTH, `consumer-as-input nesting exceeds MAX_CONSUMER_INPUT_DEPTH (${Constants_default.defaults.MAX_CONSUMER_INPUT_DEPTH}): ${stack.join(" -> ")}`);
           for (const name of upstreamNames) {
             const cached = this.cache.get(name);
-            if (!cached || !import_fs21.default.existsSync(cached.path)) {
+            if (!cached || !import_fs24.default.existsSync(cached.path)) {
               Affirm_default(!stack.includes(name), `consumer-as-input cycle detected: ${[...stack, name].join(" -> ")}`);
               const upstream = Environment_default.getConsumer(name);
               Affirm_default(upstream, `consumer-as-input references unknown consumer "${name}"`);
@@ -56238,7 +57227,7 @@ var init_ConsumerInputResolver = __esm({
               ExecutorScope_default.ensurePath(capturePath);
               await this.runUpstreamConsumer(upstream, capturePath, stack, request);
               const { size } = await import_promises18.default.stat(capturePath);
-              this.cache.set(name, { consumer: name, path: import_path21.default.resolve(capturePath), fileSize: size });
+              this.cache.set(name, { consumer: name, path: import_path23.default.resolve(capturePath), fileSize: size });
             }
             manifest.set(name, this.cache.get(name));
           }
@@ -56300,12 +57289,12 @@ var ExecutorOrchestrator_exports = {};
 __export(ExecutorOrchestrator_exports, {
   default: () => ExecutorOrchestrator_default
 });
-var import_fs22, import_promises19, import_path22, import_workerpool, import_promises20, ExecutorOrchestratorClass, ExecutorOrchestrator, ExecutorOrchestrator_default;
+var import_fs25, import_promises19, import_path24, import_workerpool, import_promises20, ExecutorOrchestratorClass, ExecutorOrchestrator, ExecutorOrchestrator_default;
 var init_ExecutorOrchestrator = __esm({
   "../../packages/executors/src/ExecutorOrchestrator.ts"() {
-    import_fs22 = __toESM(require("fs"));
+    import_fs25 = __toESM(require("fs"));
     import_promises19 = __toESM(require("fs/promises"));
-    import_path22 = __toESM(require("path"));
+    import_path24 = __toESM(require("path"));
     import_workerpool = __toESM(require("workerpool"));
     init_src();
     init_src10();
@@ -56360,7 +57349,7 @@ var init_ExecutorOrchestrator = __esm({
           };
           const workerPath = OrchestratorHelper_default.getPhysicalWorkerPath();
           Logger_default.info(`Initializing worker pool from ${workerPath} (workers: ${maxWorkers}, heap limit: ${Constants_default.defaults.MIN_RUNTIME_HEAP_MB}MB) | ${OrchestratorHelper_default.formatMemoryUsage()}`);
-          return import_workerpool.default.pool(import_path22.default.join(workerPath, "ExecutorWorker.js"), options2);
+          return import_workerpool.default.pool(import_path24.default.join(workerPath, "ExecutorWorker.js"), options2);
         };
         this.launch = async (request) => {
           Affirm_default(request, "Invalid options");
@@ -56564,7 +57553,7 @@ var init_ExecutorOrchestrator = __esm({
               Logger_default.info(`[${usageId}] Producer "${prod.name}": source returned no files, skipping`);
               continue;
             }
-            if (!import_fs22.default.existsSync(response.files[0].fullUri)) {
+            if (!import_fs25.default.existsSync(response.files[0].fullUri)) {
               if (!cProd.isOptional)
                 throw new Error(`Expected data file ${response.files[0].fullUri} of producer ${prod.name} in consumer ${consumer.name} is missing.`);
               Logger_default.info(`[${usageId}] Producer "${prod.name}": data file missing but marked optional, skipping`);
@@ -56726,7 +57715,7 @@ var init_ExecutorOrchestrator = __esm({
          * Returns a single chunk for small files where parallelism overhead isn't worth it.
          */
         this.scopeWork = (fileUri, numChunks) => {
-          const fileSize = import_fs22.default.statSync(fileUri).size;
+          const fileSize = import_fs25.default.statSync(fileUri).size;
           if (fileSize === 0) return [];
           if (fileSize < Constants_default.defaults.MIN_FILE_SIZE_FOR_PARALLEL) {
             return [{ start: 0, end: fileSize, isFirstChunk: true, fileUri, index: 0 }];
@@ -56736,7 +57725,7 @@ var init_ExecutorOrchestrator = __esm({
           const effectiveChunks = Math.min(targetWorkers, maxChunksBySize);
           if (effectiveChunks <= 1) return [{ start: 0, end: fileSize, isFirstChunk: true, fileUri, index: 0 }];
           const targetChunkSize = Math.floor(fileSize / effectiveChunks);
-          const fd = import_fs22.default.openSync(fileUri, "r");
+          const fd = import_fs25.default.openSync(fileUri, "r");
           try {
             const offsets = [];
             let currentStart = 0;
@@ -56754,7 +57743,7 @@ var init_ExecutorOrchestrator = __esm({
             }
             return offsets;
           } finally {
-            import_fs22.default.closeSync(fd);
+            import_fs25.default.closeSync(fd);
           }
         };
         /**
@@ -56822,7 +57811,7 @@ var init_ExecutorOrchestrator = __esm({
           let currentPos = position;
           while (currentPos < fileSize) {
             const bytesToRead = Math.min(BUFFER_SIZE, fileSize - currentPos);
-            const bytesRead = import_fs22.default.readSync(fd, buffer, 0, bytesToRead, currentPos);
+            const bytesRead = import_fs25.default.readSync(fd, buffer, 0, bytesToRead, currentPos);
             if (bytesRead === 0) break;
             for (let i6 = 0; i6 < bytesRead; i6++) {
               if (buffer[i6] === 10) {
@@ -56841,16 +57830,16 @@ var init_ExecutorOrchestrator = __esm({
          * format has no header row, so each row is reprojected. Without a captureFormat it's a verbatim copy.
          */
         this.captureDataset = async (consumer, fields, sourcePath, targetPath, captureFormat) => {
-          await import_promises19.default.mkdir(import_path22.default.dirname(targetPath), { recursive: true });
+          await import_promises19.default.mkdir(import_path24.default.dirname(targetPath), { recursive: true });
           const internalFormat = OutputExecutor_default._getInternalRecordFormat(consumer);
           if (captureFormat !== "JSONL" || internalFormat !== "CSV") {
             await import_promises19.default.copyFile(sourcePath, targetPath);
             return;
           }
           const visibleFields = fields.filter((field) => !field.cField.hidden);
-          const output = import_fs22.default.createWriteStream(targetPath);
+          const output = import_fs25.default.createWriteStream(targetPath);
           try {
-            for await (const line of readLines(import_fs22.default.createReadStream(sourcePath))) {
+            for await (const line of readLines(import_fs25.default.createReadStream(sourcePath))) {
               if (!line.length) continue;
               const record = LineParser_default._internalParseCSV(line, visibleFields, ",");
               if (!output.write(JSON.stringify(record) + "\n"))
@@ -56938,7 +57927,7 @@ var init_ExecutorOrchestrator = __esm({
             const decodedFiles = [];
             let decodedCount = 0;
             for (const file of response.files) {
-              const inferredType = fileType ?? import_path22.default.extname(file.fullUri).replace(".", "").toUpperCase();
+              const inferredType = fileType ?? import_path24.default.extname(file.fullUri).replace(".", "").toUpperCase();
               const decodedPath = `${file.fullUri}.decoded.csv`;
               if (inferredType === "XLS" || inferredType === "XLSX") {
                 const xlsCsvStream = await XLSParser_default.getStreamXls(file.fullUri, {
@@ -56948,7 +57937,7 @@ var init_ExecutorOrchestrator = __esm({
                 });
                 await (0, import_promises20.pipeline)(
                   xlsCsvStream,
-                  import_fs22.default.createWriteStream(decodedPath)
+                  import_fs25.default.createWriteStream(decodedPath)
                 );
                 const fileStats = await import_promises19.default.stat(decodedPath);
                 decodedFiles.push({ fullUri: decodedPath, fileSize: fileStats.size });
@@ -57008,8 +57997,8 @@ var init_ExecutorOrchestrator = __esm({
             const perf = performance.now();
             for (const workerResult of executorResults) {
               await (0, import_promises20.pipeline)(
-                import_fs22.default.createReadStream(workerResult.resultUri),
-                import_fs22.default.createWriteStream(mainPath, { flags: "a" })
+                import_fs25.default.createReadStream(workerResult.resultUri),
+                import_fs25.default.createWriteStream(mainPath, { flags: "a" })
               );
               await import_promises19.default.unlink(workerResult.resultUri);
             }
@@ -57047,7 +58036,7 @@ init_src();
 init_ConsumerExecutor();
 
 // ../../packages/executors/src/Executor.ts
-var import_fs19 = __toESM(require("fs"));
+var import_fs22 = __toESM(require("fs"));
 init_ProducerExecutor();
 init_ConsumerExecutor();
 
@@ -57337,18 +58326,18 @@ var Executor = class {
       if (!lookups?.length) return;
       for (const entry of lookups) {
         if (LookupRegistry_default.has(entry.id)) continue;
-        const table = JSON.parse(import_fs19.default.readFileSync(entry.path, "utf-8"));
+        const table = JSON.parse(import_fs22.default.readFileSync(entry.path, "utf-8"));
         LookupRegistry_default.set(entry.id, table);
         Logger_default.log(`[lookup] Hydrated table "${entry.consumer}" (${entry.key}->${entry.value}) from ${entry.path}`);
       }
     };
     this.openReadStream = (chunk) => {
       const { end, fileUri, start } = chunk;
-      return import_fs19.default.createReadStream(fileUri, { start, end: end - 1 });
+      return import_fs22.default.createReadStream(fileUri, { start, end: end - 1 });
     };
     this.openWriteStream = (scope, workerId) => {
       const workerPath = ExecutorScope_default.getWorkerPath(scope, workerId);
-      return new BatchWriter_default(import_fs19.default.createWriteStream(workerPath));
+      return new BatchWriter_default(import_fs22.default.createWriteStream(workerPath));
     };
     // The first line of the first chunk is data unless the file type carries a header there.
     this.shouldProcessFirstLine = (producer) => {
@@ -57454,9 +58443,9 @@ init_OutputExecutor();
 init_ProducerExecutor();
 
 // ../../packages/executors/src/SampleRunner.ts
-var import_fs23 = __toESM(require("fs"));
+var import_fs26 = __toESM(require("fs"));
 var import_promises21 = __toESM(require("fs/promises"));
-var import_path23 = __toESM(require("path"));
+var import_path25 = __toESM(require("path"));
 init_src();
 init_src3();
 init_src4();
@@ -57501,7 +58490,7 @@ var SampleRunnerClass = class {
      */
     this._runConsumer = async (consumer, size, details) => {
       this._assertStageable(consumer);
-      const capturePath = import_path23.default.resolve(import_path23.default.join(ExecutorScope_default.getBasePath(), `sample_${consumer.name}_${Helper_default.uuid()}.jsonl`));
+      const capturePath = import_path25.default.resolve(import_path25.default.join(ExecutorScope_default.getBasePath(), `sample_${consumer.name}_${Helper_default.uuid()}.jsonl`));
       ExecutorScope_default.ensurePath(capturePath);
       try {
         const result = await ExecutorOrchestrator_default.launch({
@@ -57591,9 +58580,9 @@ var SampleRunnerClass = class {
     };
     /** The captured dataset, which `captureFormat: 'JSONL'` guarantees is one JSON object per line. */
     this._readCapture = async (capturePath, size) => {
-      if (!import_fs23.default.existsSync(capturePath)) return [];
+      if (!import_fs26.default.existsSync(capturePath)) return [];
       const records = [];
-      for await (const line of readLines(import_fs23.default.createReadStream(capturePath))) {
+      for await (const line of readLines(import_fs26.default.createReadStream(capturePath))) {
         if (!line.length) continue;
         records.push(JSON.parse(line));
         if (records.length >= size) break;