@forzalabs/remora 2.0.3 → 2.1.0

package/workers/ExecutorWorker.js

@@ -1238,8 +1238,8 @@ var require_levels = __commonJS({
 var require_align = __commonJS({
   "../../node_modules/logform/align.js"(exports2, module2) {
     "use strict";
-    var format3 = require_format();
-    module2.exports = format3((info) => {
+    var format4 = require_format();
+    module2.exports = format4((info) => {
       info.message = `	${info.message}`;
       return info;
     });
@@ -1250,9 +1250,9 @@ var require_align = __commonJS({
 var require_errors = __commonJS({
   "../../node_modules/logform/errors.js"(exports2, module2) {
     "use strict";
-    var format3 = require_format();
+    var format4 = require_format();
     var { LEVEL, MESSAGE } = require_triple_beam();
-    module2.exports = format3((einfo, { stack, cause }) => {
+    module2.exports = format4((einfo, { stack, cause }) => {
       if (einfo instanceof Error) {
         const info = Object.assign({}, einfo, {
           level: einfo.level,
@@ -1388,7 +1388,7 @@ var require_cli2 = __commonJS({
 var require_combine = __commonJS({
   "../../node_modules/logform/combine.js"(exports2, module2) {
     "use strict";
-    var format3 = require_format();
+    var format4 = require_format();
     function cascade(formats) {
       if (!formats.every(isValidFormat)) {
         return;
@@ -1415,7 +1415,7 @@ var require_combine = __commonJS({
       return true;
     }
     module2.exports = (...formats) => {
-      const combinedFormat = format3(cascade(formats));
+      const combinedFormat = format4(cascade(formats));
       const instance = combinedFormat();
       instance.Format = combinedFormat.Format;
       return instance;
@@ -2024,7 +2024,7 @@ ${originalIndentation}`;
 var require_json = __commonJS({
   "../../node_modules/logform/json.js"(exports2, module2) {
     "use strict";
-    var format3 = require_format();
+    var format4 = require_format();
     var { MESSAGE } = require_triple_beam();
     var stringify = require_safe_stable_stringify();
     function replacer(key, value) {
@@ -2032,7 +2032,7 @@ var require_json = __commonJS({
         return value.toString();
       return value;
     }
-    module2.exports = format3((info, opts) => {
+    module2.exports = format4((info, opts) => {
       const jsonStringify = stringify.configure(opts);
       info[MESSAGE] = jsonStringify(info, opts.replacer || replacer, opts.space);
       return info;
@@ -2044,8 +2044,8 @@ var require_json = __commonJS({
 var require_label = __commonJS({
   "../../node_modules/logform/label.js"(exports2, module2) {
     "use strict";
-    var format3 = require_format();
-    module2.exports = format3((info, opts) => {
+    var format4 = require_format();
+    module2.exports = format4((info, opts) => {
       if (opts.message) {
         info.message = `[${opts.label}] ${info.message}`;
         return info;
@@ -2060,10 +2060,10 @@ var require_label = __commonJS({
 var require_logstash = __commonJS({
   "../../node_modules/logform/logstash.js"(exports2, module2) {
     "use strict";
-    var format3 = require_format();
+    var format4 = require_format();
     var { MESSAGE } = require_triple_beam();
     var jsonStringify = require_safe_stable_stringify();
-    module2.exports = format3((info) => {
+    module2.exports = format4((info) => {
       const logstash = {};
       if (info.message) {
         logstash["@message"] = info.message;
@@ -2084,7 +2084,7 @@ var require_logstash = __commonJS({
 var require_metadata = __commonJS({
   "../../node_modules/logform/metadata.js"(exports2, module2) {
     "use strict";
-    var format3 = require_format();
+    var format4 = require_format();
     function fillExcept(info, fillExceptKeys, metadataKey) {
       const savedKeys = fillExceptKeys.reduce((acc, key) => {
         acc[key] = info[key];
@@ -2109,7 +2109,7 @@ var require_metadata = __commonJS({
       }, {});
       return info;
     }
-    module2.exports = format3((info, opts = {}) => {
+    module2.exports = format4((info, opts = {}) => {
       let metadataKey = "metadata";
       if (opts.key) {
         metadataKey = opts.key;
@@ -2253,9 +2253,9 @@ var require_ms = __commonJS({
 var require_ms2 = __commonJS({
   "../../node_modules/logform/ms.js"(exports2, module2) {
     "use strict";
-    var format3 = require_format();
+    var format4 = require_format();
     var ms2 = require_ms();
-    module2.exports = format3((info) => {
+    module2.exports = format4((info) => {
       const curr = +/* @__PURE__ */ new Date();
       exports2.diff = curr - (exports2.prevTime || curr);
       exports2.prevTime = curr;
@@ -2270,9 +2270,9 @@ var require_pretty_print = __commonJS({
   "../../node_modules/logform/pretty-print.js"(exports2, module2) {
     "use strict";
     var inspect = require("util").inspect;
-    var format3 = require_format();
+    var format4 = require_format();
     var { LEVEL, MESSAGE, SPLAT } = require_triple_beam();
-    module2.exports = format3((info, opts = {}) => {
+    module2.exports = format4((info, opts = {}) => {
       const stripped = Object.assign({}, info);
       delete stripped[LEVEL];
       delete stripped[MESSAGE];
@@ -2306,10 +2306,10 @@ var require_printf = __commonJS({
 var require_simple = __commonJS({
   "../../node_modules/logform/simple.js"(exports2, module2) {
     "use strict";
-    var format3 = require_format();
+    var format4 = require_format();
     var { MESSAGE } = require_triple_beam();
     var jsonStringify = require_safe_stable_stringify();
-    module2.exports = format3((info) => {
+    module2.exports = format4((info) => {
       const stringifiedRest = jsonStringify(Object.assign({}, info, {
         level: void 0,
         message: void 0,
@@ -2431,14 +2431,14 @@ function assign(origObj) {
   }
   return origObj;
 }
-function parse(dateStr, format3, i18n) {
+function parse(dateStr, format4, i18n) {
   if (i18n === void 0) {
     i18n = {};
   }
-  if (typeof format3 !== "string") {
+  if (typeof format4 !== "string") {
     throw new Error("Invalid format in fecha parse");
   }
-  format3 = globalMasks[format3] || format3;
+  format4 = globalMasks[format4] || format4;
   if (dateStr.length > 1e3) {
     return null;
   }
@@ -2456,7 +2456,7 @@ function parse(dateStr, format3, i18n) {
   };
   var parseInfo = [];
   var literals = [];
-  var newFormat = format3.replace(literal, function($0, $1) {
+  var newFormat = format4.replace(literal, function($0, $1) {
     literals.push(regexEscape($1));
     return "@@@";
   });
@@ -2818,8 +2818,8 @@ var require_timestamp = __commonJS({
   "../../node_modules/logform/timestamp.js"(exports2, module2) {
     "use strict";
     var fecha2 = (init_fecha(), __toCommonJS(fecha_exports));
-    var format3 = require_format();
-    module2.exports = format3((info, opts = {}) => {
+    var format4 = require_format();
+    module2.exports = format4((info, opts = {}) => {
       if (opts.format) {
         info.timestamp = typeof opts.format === "function" ? opts.format() : fecha2.format(/* @__PURE__ */ new Date(), opts.format);
       }
@@ -2839,9 +2839,9 @@ var require_uncolorize = __commonJS({
   "../../node_modules/logform/uncolorize.js"(exports2, module2) {
     "use strict";
     var colors = require_safe();
-    var format3 = require_format();
+    var format4 = require_format();
     var { MESSAGE } = require_triple_beam();
-    module2.exports = format3((info, opts) => {
+    module2.exports = format4((info, opts) => {
       if (opts.level !== false) {
         info.level = colors.strip(info.level);
       }
@@ -2860,10 +2860,10 @@ var require_uncolorize = __commonJS({
 var require_logform = __commonJS({
   "../../node_modules/logform/index.js"(exports2) {
     "use strict";
-    var format3 = exports2.format = require_format();
+    var format4 = exports2.format = require_format();
     exports2.levels = require_levels();
     function exposeFormat(name, requireFormat) {
-      Object.defineProperty(format3, name, {
+      Object.defineProperty(format4, name, {
         get() {
           return requireFormat();
         },
@@ -2928,17 +2928,17 @@ var require_logform = __commonJS({
 var require_common = __commonJS({
   "../../node_modules/winston/lib/winston/common.js"(exports2) {
     "use strict";
-    var { format: format3 } = require("util");
+    var { format: format4 } = require("util");
     exports2.warn = {
       deprecated(prop) {
         return () => {
-          throw new Error(format3("{ %s } was removed in winston@3.0.0.", prop));
+          throw new Error(format4("{ %s } was removed in winston@3.0.0.", prop));
         };
       },
       useFormat(prop) {
         return () => {
           throw new Error([
-            format3("{ %s } was removed in winston@3.0.0.", prop),
+            format4("{ %s } was removed in winston@3.0.0.", prop),
             "Use a custom winston.format = winston.format(function) instead."
           ].join("\n"));
         };
@@ -4203,14 +4203,14 @@ var require_from = __commonJS({
       return (hint === "string" ? String : Number)(input);
     }
     var ERR_INVALID_ARG_TYPE = require_errors2().codes.ERR_INVALID_ARG_TYPE;
-    function from(Readable7, iterable, opts) {
+    function from(Readable8, iterable, opts) {
       var iterator;
       if (iterable && typeof iterable.next === "function") {
         iterator = iterable;
       } else if (iterable && iterable[Symbol.asyncIterator]) iterator = iterable[Symbol.asyncIterator]();
       else if (iterable && iterable[Symbol.iterator]) iterator = iterable[Symbol.iterator]();
       else throw new ERR_INVALID_ARG_TYPE("iterable", ["Iterable"], iterable);
-      var readable = new Readable7(_objectSpread({
+      var readable = new Readable8(_objectSpread({
         objectMode: true
       }, opts));
       var reading = false;
@@ -4250,9 +4250,9 @@ var require_from = __commonJS({
 var require_stream_readable = __commonJS({
   "../../node_modules/readable-stream/lib/_stream_readable.js"(exports2, module2) {
     "use strict";
-    module2.exports = Readable7;
+    module2.exports = Readable8;
     var Duplex;
-    Readable7.ReadableState = ReadableState;
+    Readable8.ReadableState = ReadableState;
     var EE = require("events").EventEmitter;
     var EElistenerCount = function EElistenerCount2(emitter, type) {
       return emitter.listeners(type).length;
@@ -4287,7 +4287,7 @@ var require_stream_readable = __commonJS({
     var StringDecoder;
     var createReadableStreamAsyncIterator;
     var from;
-    require_inherits()(Readable7, Stream);
+    require_inherits()(Readable8, Stream);
     var errorOrDestroy = destroyImpl.errorOrDestroy;
     var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
     function prependListener(emitter, event, fn) {
@@ -4331,9 +4331,9 @@ var require_stream_readable = __commonJS({
         this.encoding = options.encoding;
       }
     }
-    function Readable7(options) {
+    function Readable8(options) {
       Duplex = Duplex || require_stream_duplex();
-      if (!(this instanceof Readable7)) return new Readable7(options);
+      if (!(this instanceof Readable8)) return new Readable8(options);
       var isDuplex = this instanceof Duplex;
       this._readableState = new ReadableState(options, this, isDuplex);
       this.readable = true;
@@ -4343,7 +4343,7 @@ var require_stream_readable = __commonJS({
       }
       Stream.call(this);
     }
-    Object.defineProperty(Readable7.prototype, "destroyed", {
+    Object.defineProperty(Readable8.prototype, "destroyed", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -4361,12 +4361,12 @@ var require_stream_readable = __commonJS({
         this._readableState.destroyed = value;
       }
     });
-    Readable7.prototype.destroy = destroyImpl.destroy;
-    Readable7.prototype._undestroy = destroyImpl.undestroy;
-    Readable7.prototype._destroy = function(err2, cb) {
+    Readable8.prototype.destroy = destroyImpl.destroy;
+    Readable8.prototype._undestroy = destroyImpl.undestroy;
+    Readable8.prototype._destroy = function(err2, cb) {
       cb(err2);
     };
-    Readable7.prototype.push = function(chunk, encoding) {
+    Readable8.prototype.push = function(chunk, encoding) {
       var state2 = this._readableState;
       var skipChunkCheck;
       if (!state2.objectMode) {
@@ -4383,7 +4383,7 @@ var require_stream_readable = __commonJS({
       }
       return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
     };
-    Readable7.prototype.unshift = function(chunk) {
+    Readable8.prototype.unshift = function(chunk) {
       return readableAddChunk(this, chunk, null, true, false);
     };
     function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
@@ -4444,10 +4444,10 @@ var require_stream_readable = __commonJS({
       }
       return er2;
     }
-    Readable7.prototype.isPaused = function() {
+    Readable8.prototype.isPaused = function() {
       return this._readableState.flowing === false;
     };
-    Readable7.prototype.setEncoding = function(enc) {
+    Readable8.prototype.setEncoding = function(enc) {
       if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
       var decoder = new StringDecoder(enc);
       this._readableState.decoder = decoder;
@@ -4493,7 +4493,7 @@ var require_stream_readable = __commonJS({
       }
       return state2.length;
     }
-    Readable7.prototype.read = function(n4) {
+    Readable8.prototype.read = function(n4) {
       debug("read", n4);
       n4 = parseInt(n4, 10);
       var state2 = this._readableState;
@@ -4602,10 +4602,10 @@ var require_stream_readable = __commonJS({
       }
       state2.readingMore = false;
     }
-    Readable7.prototype._read = function(n4) {
+    Readable8.prototype._read = function(n4) {
       errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED("_read()"));
     };
-    Readable7.prototype.pipe = function(dest, pipeOpts) {
+    Readable8.prototype.pipe = function(dest, pipeOpts) {
       var src = this;
       var state2 = this._readableState;
       switch (state2.pipesCount) {
@@ -4708,7 +4708,7 @@ var require_stream_readable = __commonJS({
         }
       };
     }
-    Readable7.prototype.unpipe = function(dest) {
+    Readable8.prototype.unpipe = function(dest) {
       var state2 = this._readableState;
       var unpipeInfo = {
         hasUnpiped: false
@@ -4742,7 +4742,7 @@ var require_stream_readable = __commonJS({
       dest.emit("unpipe", this, unpipeInfo);
       return this;
     };
-    Readable7.prototype.on = function(ev, fn) {
+    Readable8.prototype.on = function(ev, fn) {
       var res = Stream.prototype.on.call(this, ev, fn);
       var state2 = this._readableState;
       if (ev === "data") {
@@ -4763,15 +4763,15 @@ var require_stream_readable = __commonJS({
       }
       return res;
     };
-    Readable7.prototype.addListener = Readable7.prototype.on;
-    Readable7.prototype.removeListener = function(ev, fn) {
+    Readable8.prototype.addListener = Readable8.prototype.on;
+    Readable8.prototype.removeListener = function(ev, fn) {
       var res = Stream.prototype.removeListener.call(this, ev, fn);
       if (ev === "readable") {
         process.nextTick(updateReadableListening, this);
       }
       return res;
     };
-    Readable7.prototype.removeAllListeners = function(ev) {
+    Readable8.prototype.removeAllListeners = function(ev) {
       var res = Stream.prototype.removeAllListeners.apply(this, arguments);
       if (ev === "readable" || ev === void 0) {
         process.nextTick(updateReadableListening, this);
@@ -4791,7 +4791,7 @@ var require_stream_readable = __commonJS({
       debug("readable nexttick read 0");
       self2.read(0);
     }
-    Readable7.prototype.resume = function() {
+    Readable8.prototype.resume = function() {
       var state2 = this._readableState;
       if (!state2.flowing) {
         debug("resume");
@@ -4817,7 +4817,7 @@ var require_stream_readable = __commonJS({
       flow(stream);
       if (state2.flowing && !state2.reading) stream.read(0);
     }
-    Readable7.prototype.pause = function() {
+    Readable8.prototype.pause = function() {
       debug("call pause flowing=%j", this._readableState.flowing);
       if (this._readableState.flowing !== false) {
         debug("pause");
@@ -4832,7 +4832,7 @@ var require_stream_readable = __commonJS({
       debug("flow", state2.flowing);
       while (state2.flowing && stream.read() !== null) ;
     }
-    Readable7.prototype.wrap = function(stream) {
+    Readable8.prototype.wrap = function(stream) {
       var _this = this;
       var state2 = this._readableState;
       var paused = false;
@@ -4877,14 +4877,14 @@ var require_stream_readable = __commonJS({
       return this;
     };
     if (typeof Symbol === "function") {
-      Readable7.prototype[Symbol.asyncIterator] = function() {
+      Readable8.prototype[Symbol.asyncIterator] = function() {
         if (createReadableStreamAsyncIterator === void 0) {
           createReadableStreamAsyncIterator = require_async_iterator();
         }
         return createReadableStreamAsyncIterator(this);
       };
     }
-    Object.defineProperty(Readable7.prototype, "readableHighWaterMark", {
+    Object.defineProperty(Readable8.prototype, "readableHighWaterMark", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -4893,7 +4893,7 @@ var require_stream_readable = __commonJS({
         return this._readableState.highWaterMark;
       }
     });
-    Object.defineProperty(Readable7.prototype, "readableBuffer", {
+    Object.defineProperty(Readable8.prototype, "readableBuffer", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -4902,7 +4902,7 @@ var require_stream_readable = __commonJS({
         return this._readableState && this._readableState.buffer;
       }
     });
-    Object.defineProperty(Readable7.prototype, "readableFlowing", {
+    Object.defineProperty(Readable8.prototype, "readableFlowing", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -4916,8 +4916,8 @@ var require_stream_readable = __commonJS({
         }
       }
     });
-    Readable7._fromList = fromList;
-    Object.defineProperty(Readable7.prototype, "readableLength", {
+    Readable8._fromList = fromList;
+    Object.defineProperty(Readable8.prototype, "readableLength", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -4963,11 +4963,11 @@ var require_stream_readable = __commonJS({
       }
     }
     if (typeof Symbol === "function") {
-      Readable7.from = function(iterable, opts) {
+      Readable8.from = function(iterable, opts) {
         if (from === void 0) {
           from = require_from();
         }
-        return from(Readable7, iterable, opts);
+        return from(Readable8, iterable, opts);
       };
     }
     function indexOf(xs2, x2) {
@@ -4989,9 +4989,9 @@ var require_stream_duplex = __commonJS({
       return keys2;
     };
     module2.exports = Duplex;
-    var Readable7 = require_stream_readable();
+    var Readable8 = require_stream_readable();
     var Writable2 = require_stream_writable();
-    require_inherits()(Duplex, Readable7);
+    require_inherits()(Duplex, Readable8);
     {
       keys = objectKeys(Writable2.prototype);
       for (v3 = 0; v3 < keys.length; v3++) {
@@ -5004,7 +5004,7 @@ var require_stream_duplex = __commonJS({
     var v3;
     function Duplex(options) {
       if (!(this instanceof Duplex)) return new Duplex(options);
-      Readable7.call(this, options);
+      Readable8.call(this, options);
       Writable2.call(this, options);
       this.allowHalfOpen = true;
       if (options) {
@@ -6546,7 +6546,7 @@ var require_pipeline = __commonJS({
       if (typeof streams[streams.length - 1] !== "function") return noop;
       return streams.pop();
     }
-    function pipeline5() {
+    function pipeline6() {
       for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
         streams[_key] = arguments[_key];
       }
@@ -6569,7 +6569,7 @@ var require_pipeline = __commonJS({
       });
       return streams.reduce(pipe);
     }
-    module2.exports = pipeline5;
+    module2.exports = pipeline6;
   }
 });
 
@@ -10323,7 +10323,7 @@ var require_logger = __commonJS({
        */
       configure({
         silent,
-        format: format3,
+        format: format4,
         defaultMeta,
         levels,
         level = "info",
@@ -10342,7 +10342,7 @@ var require_logger = __commonJS({
           this.clear();
         }
         this.silent = silent;
-        this.format = format3 || this.format || require_json()();
+        this.format = format4 || this.format || require_json()();
         this.defaultMeta = defaultMeta || null;
         this.levels = levels || this.levels || config.npm.levels;
         this.level = level;
@@ -11164,18 +11164,32 @@ ${stack}` : base;
 });
 
 // ../../packages/logger/src/logger/Logger.ts
-var import_chalk, MAX_CAUSE_DEPTH, Logger, logger, Logger_default;
+var import_util, import_chalk, MAX_CAUSE_DEPTH, LOG_RECORD_VERSION, MAX_FIELD_CHARS, ANSI_PATTERN, nativeConsole, Logger, logger, Logger_default;
 var init_Logger = __esm({
   "../../packages/logger/src/logger/Logger.ts"() {
+    import_util = require("util");
+    init_src();
     import_chalk = __toESM(require("chalk"), 1);
     init_FileLogService();
     MAX_CAUSE_DEPTH = 10;
+    LOG_RECORD_VERSION = 1;
+    MAX_FIELD_CHARS = 3e4;
+    ANSI_PATTERN = /\u001B\[[0-9;]*m/g;
+    nativeConsole = {
+      log: console.log.bind(console),
+      info: console.info.bind(console),
+      warn: console.warn.bind(console),
+      error: console.error.bind(console)
+    };
     Logger = class {
       constructor() {
         // Counts lines written to the console. In-place TTY renderers (the CLI progress bar) read it to
         // detect that something else has printed since their last frame, so they redraw on a new line
         // instead of moving the cursor up and overwriting a log message.
         this._consoleWrites = 0;
+        // Whether console.* has been redirected into this logger. Once per process, and one-way: our
+        // own writes use `nativeConsole`, so there is nothing to restore it for.
+        this._consoleCaptured = false;
         this.setLevel = (level) => this._level = level;
         this.enableFileLogging = (folder, file) => {
           this._fileLoggingFolder = folder;
@@ -11209,9 +11223,28 @@ var init_Logger = __esm({
           this._level = "debug";
           if (fileLoggingFolder && process.env.NODE_ENV !== "development") {
             this.enableFileLogging(fileLoggingFolder);
-            console.error("Enabled file logger.");
+            nativeConsole.error("Enabled file logger.");
           }
         };
+        /**
+         * Routes `console.*` through this logger, so code that never heard of it still writes one line
+         * per record. Call once from a deployed process entrypoint; a no-op under the `text` format,
+         * where a human is reading the console and Node's own formatting is the better rendering.
+         *
+         * Interception rather than a sweep of the call sites: the requirement is about the STREAM, not
+         * about our code — an express handler, a driver and a dependency all write to the same stdout,
+         * and a rule enforced at the call sites is a rule that the next `console.error` breaks.
+         */
+        this.captureConsole = () => {
+          if (this._consoleCaptured) return;
+          if (this.consoleFormat() !== "json") return;
+          this._consoleCaptured = true;
+          console.log = (...args) => this.info((0, import_util.format)(...args));
+          console.info = console.log;
+          console.debug = (...args) => this.log((0, import_util.format)(...args));
+          console.warn = (...args) => this.warn((0, import_util.format)(...args));
+          console.error = (...args) => args.length === 1 && args[0] instanceof Error ? this.error(args[0]) : this.error((0, import_util.format)(...args));
+        };
         // The file sink replaces the console only for the CLI: there a human is watching the progress bar
         // and can read the log file afterwards. Anywhere else that file sits on an ephemeral container
         // layer nobody reads, and stdout is the only sink reaching the log driver (ECS -> CloudWatch), so
@@ -11222,18 +11255,15 @@ var init_Logger = __esm({
           if (myLevel !== "debug") return;
           FileLogService_default.write("DEBUG", String(message));
           if (this.isConsoleSuppressed()) return;
-          console.log(import_chalk.default.cyanBright("DEBUG"), message);
-          this._consoleWrites++;
+          this.writeConsole("debug", message);
         };
         this.info = (message) => {
           FileLogService_default.write("INFO", String(message));
           if (this.isConsoleSuppressed()) return;
-          console.info(message);
-          this._consoleWrites++;
+          this.writeConsole("info", message);
         };
         this.warn = (message) => {
-          console.warn(message);
-          this._consoleWrites++;
+          this.writeConsole("warn", message);
           FileLogService_default.write("WARN", String(message));
         };
         this.flush = () => FileLogService_default.flush();
@@ -11251,11 +11281,88 @@ var init_Logger = __esm({
             message = String(error);
           }
           const suppressed = this.isConsoleSuppressed();
-          console.error(message);
-          this._consoleWrites++;
+          this.writeConsole("error", message, suppressed ? void 0 : stack);
           FileLogService_default.write("ERROR", message, stack);
-          if (stack && !suppressed)
-            console.error(stack);
+        };
+        /**
+         * How console records are rendered: `text` for a human at a terminal, `json` for a log pipeline.
+         *
+         * Deployed processes default to `json` because there ONE RECORD MUST BE ONE LINE: the awslogs
+         * driver turns every newline on stdout into its own CloudWatch event, so a stack trace arrived as
+         * thirty separate events, none of them carrying the message they belonged to, interleaved with
+         * whatever the other threads were writing. `REMORA_LOG_FORMAT` overrides the default either way.
+         * Same rule as StateEmitter, whose records share the stream.
+         */
+        this.consoleFormat = () => {
+          const configured = process.env.REMORA_LOG_FORMAT?.toLowerCase();
+          if (configured === "json" || configured === "text")
+            return configured;
+          return process.env.REMORA_RUNTIME_CONTEXT === "cli" ? "text" : "json";
+        };
+        /**
+         * The one place anything of ours reaches the console.
+         *
+         * `stack` belongs to the record it explains: a second line in text mode, a field of the same JSON
+         * object in json mode — never a record of its own, which is how it would lose its message.
+         */
+        this.writeConsole = (level, message, stack) => {
+          this._consoleWrites++;
+          if (this.consoleFormat() === "json")
+            return this.writeJson(level, message, stack);
+          this.writeText(level, message, stack);
+        };
+        this.writeText = (level, message, stack) => {
+          if (level === "debug")
+            nativeConsole.log(import_chalk.default.cyanBright("DEBUG"), message);
+          else if (level === "info")
+            nativeConsole.info(message);
+          else if (level === "warn")
+            nativeConsole.warn(message);
+          else
+            nativeConsole.error(message);
+          if (stack)
+            nativeConsole.error(stack);
+        };
+        /**
+         * One JSON object, one line, one log event. Written straight to the stream rather than through
+         * `console`, which reformats and re-wraps what it is given.
+         */
+        this.writeJson = (level, message, stack) => {
+          const record = {
+            remora: "log",
+            v: LOG_RECORD_VERSION,
+            ts: DSTE_default.now().toISOString(),
+            level,
+            message: this.asField(message),
+            ...stack ? { stack: this.asField(stack) } : {}
+          };
+          const stream = level === "warn" || level === "error" ? process.stderr : process.stdout;
+          stream.write(`${this.stringify(record)}
+`);
+        };
+        /** A loggable value as one clamped, colour-free string. */
+        this.asField = (value) => {
+          const plain = this.asText(value).replace(ANSI_PATTERN, "");
+          if (plain.length <= MAX_FIELD_CHARS)
+            return plain;
+          return `${plain.slice(0, MAX_FIELD_CHARS)}\u2026[+${plain.length - MAX_FIELD_CHARS} chars]`;
+        };
+        this.asText = (value) => {
+          if (typeof value === "string")
+            return value;
+          if (value instanceof Error)
+            return value.stack ?? value.message;
+          if (typeof value === "object" && value !== null)
+            return this.stringify(value);
+          return String(value);
+        };
+        /** JSON.stringify that cannot throw: a circular or unserializable value still has to be logged. */
+        this.stringify = (value) => {
+          try {
+            return JSON.stringify(value);
+          } catch {
+            return String(value);
+          }
         };
         // Node's Error.stack omits `cause` — only util.inspect renders it, and we log strings rather
         // than Error objects. Without unwrapping here the root reason of a wrapped error is lost on any
@@ -11575,7 +11682,7 @@ var CONSTANTS, Constants_default;
 var init_Constants = __esm({
   "../../packages/constants/src/Constants.ts"() {
     CONSTANTS = {
-      cliVersion: "2.0.3",
+      cliVersion: "2.1.0",
       backendVersion: 1,
       backendPort: 5088,
       workerVersion: 2,
@@ -12624,10 +12731,10 @@ var init_Validator = __esm({
               errors.push(`There are outputs with the same type. (duplicates type: ${duplicatesTypes.join(" and ")})`);
             }
             for (const output of consumer.outputs) {
-              const format3 = output.format.toUpperCase();
-              if (format3 === "CSV" || format3 === "JSON" || format3 === "PARQUET" || format3 === "TXT") {
+              const format4 = output.format.toUpperCase();
+              if (format4 === "CSV" || format4 === "JSON" || format4 === "PARQUET" || format4 === "TXT") {
                 if (!output.exportDestination)
-                  errors.push(`A static file output must have an export destination set (${format3})`);
+                  errors.push(`A static file output must have an export destination set (${format4})`);
                 else if (!Environment_default.getSource(output.exportDestination))
                   errors.push(`The export destination "${output.exportDestination}" was not found in the sources.`);
               }
@@ -12699,14 +12806,14 @@ var init_Validator = __esm({
           const errors = [];
           const positionalFormats = ["CSV", "TXT", "PARQUET"];
           for (const output of (consumer.outputs ?? []).filter((x2) => x2.omitNull === true)) {
-            const format3 = output.format.toUpperCase();
-            if (positionalFormats.includes(format3)) {
-              errors.push(`The ${format3} output of consumer "${consumer.name}" declares "omitNull", which only applies to JSON/API output: a positional column can't be omitted from a row.`);
+            const format4 = output.format.toUpperCase();
+            if (positionalFormats.includes(format4)) {
+              errors.push(`The ${format4} output of consumer "${consumer.name}" declares "omitNull", which only applies to JSON/API output: a positional column can't be omitted from a row.`);
               continue;
             }
             const positional = (consumer.outputs ?? []).filter((x2) => positionalFormats.includes(x2.format.toUpperCase()));
             if (positional.length > 0)
-              errors.push(`The ${format3} output of consumer "${consumer.name}" declares "omitNull", but the consumer also writes ${positional.map((x2) => x2.format.toUpperCase()).join(" and ")}. Every output is serialized from one record, so omitting fields would break the positional one \u2014 split them into two consumers.`);
+              errors.push(`The ${format4} output of consumer "${consumer.name}" declares "omitNull", but the consumer also writes ${positional.map((x2) => x2.format.toUpperCase()).join(" and ")}. Every output is serialized from one record, so omitting fields would break the positional one \u2014 split them into two consumers.`);
           }
           return errors;
         };
@@ -17759,17 +17866,17 @@ var init_split_header = __esm({
 });
 
 // ../../node_modules/@smithy/core/dist-es/submodules/serde/value/NumericValue.js
-var format2, NumericValue;
+var format3, NumericValue;
 var init_NumericValue = __esm({
   "../../node_modules/@smithy/core/dist-es/submodules/serde/value/NumericValue.js"() {
-    format2 = /^-?\d*(\.\d+)?$/;
+    format3 = /^-?\d*(\.\d+)?$/;
     NumericValue = class _NumericValue {
       string;
       type;
       constructor(string, type) {
         this.string = string;
         this.type = type;
-        if (!format2.test(string)) {
+        if (!format3.test(string)) {
           throw new Error(`@smithy/core/serde - NumericValue must only contain [0-9], at most one decimal point ".", and an optional negation prefix "-".`);
         }
       }
@@ -17781,7 +17888,7 @@ var init_NumericValue = __esm({
           return false;
         }
         const _nv = object;
-        return _NumericValue.prototype.isPrototypeOf(object) || _nv.type === "bigDecimal" && format2.test(_nv.string);
+        return _NumericValue.prototype.isPrototypeOf(object) || _nv.type === "bigDecimal" && format3.test(_nv.string);
       }
     };
   }
@@ -21246,8 +21353,8 @@ var init_FromStringShapeDeserializer = __esm({
           return (this.serdeContext?.base64Decoder ?? fromBase64)(data);
         }
         if (ns2.isTimestampSchema()) {
-          const format3 = determineTimestampFormat(ns2, this.settings);
-          switch (format3) {
+          const format4 = determineTimestampFormat(ns2, this.settings);
+          switch (format4) {
             case 5:
               return _parseRfc3339DateTimeWithOffset(data);
             case 6:
@@ -21369,8 +21476,8 @@ var init_ToStringShapeSerializer = __esm({
               if (!(value instanceof Date)) {
                 throw new Error(`@smithy/core/protocols - received non-Date value ${value} when schema expected Date in ${ns2.getName(true)}`);
               }
-              const format3 = determineTimestampFormat(ns2, this.settings);
-              switch (format3) {
+              const format4 = determineTimestampFormat(ns2, this.settings);
+              switch (format4) {
                 case 5:
                   this.stringBuffer = value.toISOString().replace(".000Z", "Z");
                   break;
@@ -26604,8 +26711,8 @@ var init_JsonShapeDeserializer = __esm({
           return value;
         }
         if (ns2.isTimestampSchema() && value != null) {
-          const format3 = determineTimestampFormat(ns2, this.settings);
-          switch (format3) {
+          const format4 = determineTimestampFormat(ns2, this.settings);
+          switch (format4) {
             case 5:
               return parseRfc3339DateTimeWithOffset(value);
             case 6:
@@ -26829,8 +26936,8 @@ var init_JsonShapeSerializer = __esm({
             return (this.serdeContext?.base64Encoder ?? toBase64)(value);
           }
           if (value instanceof Date && (ns2.isTimestampSchema() || ns2.isDocumentSchema())) {
-            const format3 = determineTimestampFormat(ns2, this.settings);
-            switch (format3) {
+            const format4 = determineTimestampFormat(ns2, this.settings);
+            switch (format4) {
               case 5:
                 return value.toISOString().replace(".000Z", "Z");
               case 6:
@@ -27458,8 +27565,8 @@ var init_QueryShapeSerializer = __esm({
         } else if (ns2.isTimestampSchema()) {
           if (value instanceof Date) {
             this.writeKey(prefix2);
-            const format3 = determineTimestampFormat(ns2, this.settings);
-            switch (format3) {
+            const format4 = determineTimestampFormat(ns2, this.settings);
+            switch (format4) {
               case 5:
                 this.writeValue(value.toISOString().replace(".000Z", "Z"));
                 break;
@@ -41894,11 +42001,13 @@ var init_src6 = __esm({
 });
 
 // ../../packages/drivers/src/DeltaShareDriver.ts
-var fs9, import_promises7, MAX_LIMIT_HINT, DeltaShareSourceDriver, DeltaShareDriver_default;
+var fs9, import_promises7, import_stream, import_promises8, MAX_LIMIT_HINT, PARQUET_BATCH_ROWS, DeltaShareSourceDriver, DeltaShareDriver_default;
 var init_DeltaShareDriver = __esm({
   "../../packages/drivers/src/DeltaShareDriver.ts"() {
     fs9 = __toESM(require("fs"), 1);
     import_promises7 = __toESM(require("fs/promises"), 1);
+    import_stream = require("stream");
+    import_promises8 = require("stream/promises");
     init_src();
     init_src4();
     init_src2();
@@ -41906,6 +42015,7 @@ var init_DeltaShareDriver = __esm({
     init_DeltaSharePredicate();
     init_OidcTokenProvider();
     MAX_LIMIT_HINT = 2147483647;
+    PARQUET_BATCH_ROWS = 5e4;
     DeltaShareSourceDriver = class {
       constructor() {
         this._query = "{prefix}/shares/{share}/schemas/{schema}/tables/{table}/query";
@@ -41915,6 +42025,9 @@ var init_DeltaShareDriver = __esm({
         // Column Delta types per table, for the predicate's literals. A table's schema does not change
         // under a run, and only a read with something to push ever asks for it.
         this._columnTypes = /* @__PURE__ */ new Map();
+        // Rows held as objects at once. A run leaves this at PARQUET_BATCH_ROWS; the tests lower it so a
+        // fixture small enough to read whole still splits its row groups the way a real part file does.
+        this._batchRows = PARQUET_BATCH_ROWS;
         this.init = async (source) => {
           Affirm_default(source, "Invalid source");
           const { authentication } = source;
@@ -41975,12 +42088,11 @@ var init_DeltaShareDriver = __esm({
           Affirm_default(request, "Invalid download request");
           const table = this._resolveTable(request.fileKey);
           const deltaFiles = await this._getAllFilesInTable(table, request.disableHistory);
-          const hyparquet = await import("hyparquet");
           const lines = [];
-          for (const deltaFile of deltaFiles) {
-            const parquetRecords = await this._readParquetObjects(deltaFile);
-            lines.push(...parquetRecords.map((x2) => JSON.stringify(hyparquet.toJson(x2))));
-          }
+          for (const deltaFile of deltaFiles)
+            for await (const batch of this._readRemoteParquetBatches(deltaFile))
+              for (const record of batch)
+                lines.push(JSON.stringify(record));
           Logger_default.log(`Delta Share readAll: ${lines.length} record(s) from ${deltaFiles.length} file(s) of table "${table}"`);
           return lines;
         };
@@ -41990,22 +42102,41 @@ var init_DeltaShareDriver = __esm({
           Affirm_default(request.options.lineFrom !== void 0 && request.options.lineTo !== void 0, "Missing read range");
           const table = this._resolveTable(request.fileKey);
           const deltaFiles = await this._getAllFilesInTable(table, request.disableHistory);
-          const hyparquet = await import("hyparquet");
           const { options: { lineFrom, lineTo } } = request;
+          const lines = await this._collectLinesInRange(deltaFiles, { from: lineFrom, to: lineTo });
+          Logger_default.log(`Delta Share readLinesInRange [${lineFrom}, ${lineTo}) on table "${table}": ${lines.length} record(s)`);
+          return lines;
+        };
+        /**
+         * The records of the given range, serialized. Reading stops the moment the range is filled: a
+         * part file holds hundreds of thousands of rows and a preview asks for a handful of them, so
+         * decoding past `to` is both slow and the memory the batching above exists to avoid.
+         */
+        this._collectLinesInRange = async (deltaFiles, range2) => {
+          if (range2.to <= range2.from)
+            return [];
           const lines = [];
           let index = 0;
           for (const deltaFile of deltaFiles) {
-            const parquetRecords = await this._readParquetObjects(deltaFile);
-            for (const record of parquetRecords) {
-              if (index >= lineFrom && index < lineTo)
-                lines.push(JSON.stringify(hyparquet.toJson(record)));
-              index++;
-              if (index >= lineTo) break;
+            for await (const batch of this._readRemoteParquetBatches(deltaFile)) {
+              index = this._pushRecordsInRange(lines, batch, index, range2);
+              if (index >= range2.to)
+                return lines;
             }
           }
-          Logger_default.log(`Delta Share readLinesInRange [${lineFrom}, ${lineTo}) on table "${table}": ${lines.length} record(s)`);
           return lines;
         };
+        // The index the batch ends on, so the next batch carries on counting where this one stopped.
+        this._pushRecordsInRange = (lines, batch, index, range2) => {
+          for (const record of batch) {
+            if (index >= range2.from && index < range2.to)
+              lines.push(JSON.stringify(record));
+            index++;
+            if (index >= range2.to)
+              break;
+          }
+          return index;
+        };
         this.exist = async (_producer) => {
           void _producer;
           let nextPageToken;
@@ -42149,20 +42280,48 @@ var init_DeltaShareDriver = __esm({
             return "(unparseable url)";
           }
         };
-        this._readParquetObjects = async (deltaFile) => {
+        // Split out so the batch loop above stays one level of nesting, and so both failures name the file
+        this._readParquetMetadata = async (file, label) => {
           const hyparquet = await import("hyparquet");
-          const { compressors: compressors2 } = await Promise.resolve().then(() => (init_src6(), src_exports));
-          const byteLength = deltaFile.file.deltaSingleAction.add?.size ?? deltaFile.file.deltaSingleAction.remove?.size;
-          const startedMs = Date.now();
-          let records;
           try {
-            const file = await hyparquet.asyncBufferFromUrl({ url: deltaFile.file.url, byteLength });
-            records = await hyparquet.parquetReadObjects({ file, compressors: compressors2 });
+            return await hyparquet.parquetMetadataAsync(file);
           } catch (error) {
-            throw new Error(`Delta Share failed reading parquet from ${this._redactUrl(deltaFile.file.url)} (${byteLength ?? "?"} bytes)`, { cause: error });
+            throw new Error(`Delta Share failed reading the parquet footer of ${label}`, { cause: error });
+          }
+        };
+        this._readParquetBatch = async (options, label) => {
+          const hyparquet = await import("hyparquet");
+          try {
+            return await hyparquet.parquetReadObjects(options);
+          } catch (error) {
+            throw new Error(`Delta Share failed reading parquet rows [${options.rowStart}, ${options.rowEnd}) of ${label}`, { cause: error });
           }
-          Logger_default.log(`Delta Share read ${records.length} record(s) from ${this._redactUrl(deltaFile.file.url)} (${byteLength ?? "?"} bytes) in ${Date.now() - startedMs}ms`);
-          return records;
+        };
+        // Reads straight from the pre-signed URL. Only for the bounded readers (preview, sample): every
+        // batch refetches the row group, which is why `ready` stages the file locally instead.
+        this._readRemoteParquetBatches = (deltaFile) => {
+          const byteLength = deltaFile.file.deltaSingleAction.add?.size ?? deltaFile.file.deltaSingleAction.remove?.size;
+          const label = `${this._redactUrl(deltaFile.file.url)} (${byteLength ?? "?"} bytes)`;
+          const open = async () => {
+            const hyparquet = await import("hyparquet");
+            return await hyparquet.asyncBufferFromUrl({ url: deltaFile.file.url, byteLength });
+          };
+          return this._streamParquetBatchesFrom(open, label);
+        };
+        /**
+         * Copies a part file to local disk, streamed, so nothing but the socket buffer is ever in memory.
+         * `ready` re-reads the file once per batch and re-reading it over HTTP would refetch the same
+         * bytes every time.
+         */
+        this._downloadParquet = async (deltaFile, localPath) => {
+          const startedMs = Date.now();
+          const res = await this._fetch(deltaFile.file.url, { method: "GET" }, `parquet download of ${this._redactUrl(deltaFile.file.url)}`);
+          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));
+          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`);
         };
         this._serializeDatasetValue = (value) => {
           if (value === null || value === void 0)
@@ -42176,17 +42335,41 @@ var init_DeltaShareDriver = __esm({
         this._getDeltaFileKey = (table, index) => {
           return `${this._resolveSchema()}/${table}/part-${index}.parquet`;
         };
-        this._writeDatasetFile = async (localPath, records, delimiter) => {
-          if (records.length === 0)
-            return false;
-          const header = Object.keys(records[0]);
-          const lines = [
-            CSVParser_default.stringifyRow(header, delimiter),
-            ...records.map((record) => CSVParser_default.stringifyRow(header.map((column) => this._serializeDatasetValue(record[column])), delimiter))
-          ];
-          await import_promises7.default.writeFile(localPath, `${lines.join("\n")}
-`);
-          return true;
+        /**
+         * Writes the batches out as one CSV dataset file and reports how many records landed. Rows are
+         * written as they arrive rather than joined into one string first: a file's worth of lines, and
+         * the single string joining them, were each as large as the records themselves.
+         *
+         * The header is taken from the first record and reused for every later one, so a file whose rows
+         * disagree on their columns still produces a rectangular dataset.
+         */
+        this._writeDatasetFile = async (localPath, batches, delimiter) => {
+          const stream = fs9.createWriteStream(localPath);
+          let header = null;
+          let records = 0;
+          try {
+            for await (const batch of batches) {
+              for (const record of batch) {
+                if (!header) {
+                  header = Object.keys(record);
+                  await this._writeLine(stream, CSVParser_default.stringifyRow(header, delimiter));
+                }
+                await this._writeLine(stream, CSVParser_default.stringifyRow(header.map((column) => this._serializeDatasetValue(record[column])), delimiter));
+                records++;
+              }
+            }
+          } finally {
+            await new Promise((resolve) => stream.end(resolve));
+          }
+          return records;
+        };
+        // A false from write() means the buffer is full; waiting for the drain just then keeps the queued
+        // rows bounded instead of letting them pile up faster than the disk takes them.
+        this._writeLine = async (stream, line) => {
+          if (stream.write(`${line}
+`))
+            return;
+          await new Promise((resolve) => stream.once("drain", resolve));
         };
         /**
          * Every file the share reports for this table. `jsonPredicateHints` lets the server skip the
@@ -42250,30 +42433,22 @@ var init_DeltaShareDriver = __esm({
           const table = this._resolveTable(producer.settings.fileKey);
           const hints = await this._buildHints(producer, table, request.pushdown);
           const deltaFiles = await this._getAllFilesInTable(table, producer.settings.disableHistory, hints);
-          const hyparquet = await import("hyparquet");
           const delimiter = producer.settings.delimiter ?? ",";
           const files = [];
           let records = 0;
           let skipped = 0;
           for (const [index, deltaFile] of deltaFiles.entries()) {
             onProgress?.(index / deltaFiles.length);
-            const parquetRecords = await this._readParquetObjects(deltaFile);
-            if (parquetRecords.length === 0) {
-              skipped++;
-              Logger_default.log(`Delta Share ready: file ${index + 1}/${deltaFiles.length} of table "${table}" holds no records, skipping`);
-              continue;
-            }
             const sourceFileKey = this._getDeltaFileKey(table, index);
             const localPath = ExecutorScope_default.getProducerPath(scope, producer, sourceFileKey);
             ExecutorScope_default.ensurePath(localPath);
-            const jsonRecords = parquetRecords.map((record) => hyparquet.toJson(record));
-            const written = await this._writeDatasetFile(localPath, jsonRecords, delimiter);
-            if (written) {
+            const written = await this._stageDeltaFile(deltaFile, localPath, delimiter);
+            if (written > 0) {
               files.push({ fullUri: localPath, fileSize: fs9.statSync(localPath).size });
-              records += jsonRecords.length;
+              records += written;
             } else {
               skipped++;
-              Logger_default.log(`Delta Share ready: nothing written for ${sourceFileKey}, discarding the staged file`);
+              Logger_default.log(`Delta Share ready: file ${index + 1}/${deltaFiles.length} of table "${table}" (${sourceFileKey}) holds no records, discarding the staged file`);
               await import_promises7.default.unlink(localPath).catch(() => {
               });
             }
@@ -42284,6 +42459,57 @@ var init_DeltaShareDriver = __esm({
           Logger_default.log(`Delta Share ready: staged ${records} record(s) into ${files.length} dataset file(s) (${bytes} bytes) for producer "${producer.name}" from table "${table}"${skippedNote}`);
           return { files, filteredAtSource: !!hints?.jsonPredicateHints };
         };
+        /**
+         * One part file turned into one CSV dataset file, downloaded then converted a batch at a time so
+         * that neither step's memory grows with the file. The download is dropped either way — it is the
+         * dataset file the run reads from here on.
+         */
+        this._stageDeltaFile = async (deltaFile, localPath, delimiter) => {
+          const downloadPath = `${localPath}.parquet`;
+          await this._downloadParquet(deltaFile, downloadPath);
+          try {
+            const open = async () => {
+              const hyparquet = await import("hyparquet");
+              return await hyparquet.asyncBufferFromFile(downloadPath);
+            };
+            return await this._writeDatasetFile(localPath, this._streamParquetBatchesFrom(open, this._redactUrl(deltaFile.file.url)), delimiter);
+          } finally {
+            await import_promises7.default.unlink(downloadPath).catch(() => {
+            });
+          }
+        };
+      }
+      /**
+       * The rows of a part file, `_batchRows` at a time and already JSON-safe.
+       *
+       * hyparquet decodes a whole row group's columns per read either way, but only the requested rows
+       * are turned into objects — and the objects are what dominates — so a row group larger than a
+       * batch is read in several passes. Every pass re-reads the group's bytes, which is why `ready`
+       * stages the file on disk first and only the small readers below stream it from its URL.
+       */
+      async *_streamParquetBatches(file, label) {
+        const hyparquet = await import("hyparquet");
+        const { compressors: compressors2 } = await Promise.resolve().then(() => (init_src6(), src_exports));
+        const startedMs = Date.now();
+        const metadata = await this._readParquetMetadata(file, label);
+        let records = 0;
+        let groupStart = 0;
+        for (const rowGroup of metadata.row_groups) {
+          const groupRows = Number(rowGroup.num_rows);
+          const groupEnd = groupStart + groupRows;
+          for (let rowStart = groupStart; rowStart < groupEnd; rowStart += this._batchRows) {
+            const rowEnd = Math.min(rowStart + this._batchRows, groupEnd);
+            const batch = await this._readParquetBatch({ file, metadata, compressors: compressors2, rowStart, rowEnd }, label);
+            records += batch.length;
+            yield batch.map((record) => hyparquet.toJson(record));
+          }
+          groupStart = groupEnd;
+        }
+        Logger_default.log(`Delta Share read ${records} record(s) from ${label} in ${Date.now() - startedMs}ms`);
+      }
+      // The buffer is opened inside the generator so nothing is fetched until the first batch is pulled
+      async *_streamParquetBatchesFrom(open, label) {
+        yield* this._streamParquetBatches(await open(), label);
       }
     };
     DeltaShareDriver_default = DeltaShareSourceDriver;
@@ -42830,12 +43056,12 @@ var init_src7 = __esm({
 });
 
 // ../../packages/drivers/src/DriverHelper.ts
-var import_stream, import_readline, import_promises8, import_fs9, DriverHelper, DriverHelper_default;
+var import_stream2, import_readline, import_promises9, import_fs9, DriverHelper, DriverHelper_default;
 var init_DriverHelper = __esm({
   "../../packages/drivers/src/DriverHelper.ts"() {
-    import_stream = require("stream");
+    import_stream2 = require("stream");
     import_readline = require("readline");
-    import_promises8 = require("stream/promises");
+    import_promises9 = require("stream/promises");
     import_fs9 = require("fs");
     init_src2();
     init_src();
@@ -42852,7 +43078,7 @@ var init_DriverHelper = __esm({
         let leftoverData = "";
         let globalIndex = 0;
         let lineCount = 0;
-        const headerValidationTransform = new import_stream.Transform({
+        const headerValidationTransform = new import_stream2.Transform({
           transform(chunk, encoding, callback) {
             const chunkStr = leftoverData + chunk.toString();
             const lines = chunkStr.split("\n");
@@ -42928,7 +43154,7 @@ var init_DriverHelper = __esm({
         };
         const writeOptions = append ? { flags: "a" } : {};
         const writeStream = (0, import_fs9.createWriteStream)(destinationPath, writeOptions);
-        await (0, import_promises8.pipeline)(stream, headerValidationTransform, writeStream);
+        await (0, import_promises9.pipeline)(stream, headerValidationTransform, writeStream);
         return lineCount;
       },
       appendObjectsToUnifiedFile: async (options) => {
@@ -43238,11 +43464,11 @@ var init_LocalSourceDriver = __esm({
 });
 
 // ../../packages/drivers/src/files/LocalDestinationDriver.ts
-var fs11, import_promises9, import_readline3, import_path10, LocalDestinationDriver;
+var fs11, import_promises10, import_readline3, import_path10, LocalDestinationDriver;
 var init_LocalDestinationDriver = __esm({
   "../../packages/drivers/src/files/LocalDestinationDriver.ts"() {
     fs11 = __toESM(require("fs"), 1);
-    import_promises9 = __toESM(require("fs/promises"), 1);
+    import_promises10 = __toESM(require("fs/promises"), 1);
     import_readline3 = __toESM(require("readline"), 1);
     import_path10 = __toESM(require("path"), 1);
     init_src();
@@ -43277,8 +43503,8 @@ var init_LocalDestinationDriver = __esm({
         this.move = async (fromPath, toName) => {
           try {
             const toFilePath = import_path10.default.join(this._path, toName);
-            await import_promises9.default.copyFile(fromPath, toFilePath);
-            await import_promises9.default.unlink(fromPath);
+            await import_promises10.default.copyFile(fromPath, toFilePath);
+            await import_promises10.default.unlink(fromPath);
             return { bucket: "", key: toFilePath, res: true };
           } catch (error) {
             Logger_default.error(error);
@@ -43314,14 +43540,14 @@ var init_LocalDestinationDriver = __esm({
 });
 
 // ../../packages/drivers/src/s3/S3SourceDriver.ts
-var import_client_s32, import_stream2, import_promises10, import_readline4, import_path11, import_fs10, import_xlsx2, S3SourceDriver;
+var import_client_s32, import_stream3, import_promises11, import_readline4, import_path11, import_fs10, import_xlsx2, S3SourceDriver;
 var init_S3SourceDriver = __esm({
   "../../packages/drivers/src/s3/S3SourceDriver.ts"() {
     import_client_s32 = require("@aws-sdk/client-s3");
     init_src();
     init_AwsCredentials();
-    import_stream2 = require("stream");
-    import_promises10 = require("stream/promises");
+    import_stream3 = require("stream");
+    import_promises11 = require("stream/promises");
     import_readline4 = __toESM(require("readline"), 1);
     import_path11 = __toESM(require("path"), 1);
     import_fs10 = __toESM(require("fs"), 1);
@@ -43589,7 +43815,7 @@ var init_S3SourceDriver = __esm({
             }
             const totalBytes = response.ContentLength ?? 0;
             let stagedBytes = 0;
-            const meter = new import_stream2.Transform({
+            const meter = new import_stream3.Transform({
               transform(chunk, _encoding, done) {
                 stagedBytes += chunk.length;
                 if (totalBytes > 0)
@@ -43598,7 +43824,7 @@ var init_S3SourceDriver = __esm({
               }
             });
             const writeStream = import_fs10.default.createWriteStream(localPath);
-            await (0, import_promises10.pipeline)(response.Body, meter, writeStream);
+            await (0, import_promises11.pipeline)(response.Body, meter, writeStream);
             report(1);
           };
           if (fileKey.includes("%")) {
@@ -43978,7 +44204,7 @@ var init_TypeCaster = __esm({
        *  - Parsing dates (type 'date'/'datetime') from string with tokens: yyyy, mm, dd
        *  - Formatting dates when casting to string with same tokens
        */
-      cast(value, type, format3) {
+      cast(value, type, format4) {
         if (!Algo_default.hasVal(value)) return value;
         switch (type) {
           case "boolean": {
@@ -43989,8 +44215,8 @@ var init_TypeCaster = __esm({
           case "date": {
             let dateValue = null;
             try {
-              if (format3 && typeof value === "string")
-                dateValue = this.parseDate(value, format3, true).toDate();
+              if (format4 && typeof value === "string")
+                dateValue = this.parseDate(value, format4, true).toDate();
               else
                 dateValue = new Date(value);
               return dateValue.toISOString();
@@ -43998,7 +44224,7 @@ var init_TypeCaster = __esm({
               dateValue = new Date(value);
               if (!isNaN(dateValue))
                 return dateValue.toISOString();
-              throw new Error(`Error casting "${value}" to date with format "${format3}": ${error}`);
+              throw new Error(`Error casting "${value}" to date with format "${format4}": ${error}`);
             }
           }
           case "number": {
@@ -44025,13 +44251,13 @@ var init_TypeCaster = __esm({
        * advancedFormat plugin, and then unpadded for `DDD`, while a positional ordinal date is always
        * 3 digits wide; the token is therefore rendered here rather than handed to dayjs.
        */
-      formatDate(value, format3) {
+      formatDate(value, format4) {
         const date2 = import_dayjs.default.utc(value);
-        if (!DAY_OF_YEAR_TOKEN.test(this._stripLiterals(format3)))
-          return date2.format(format3);
+        if (!DAY_OF_YEAR_TOKEN.test(this._stripLiterals(format4)))
+          return date2.format(format4);
         const startOfYear = import_dayjs.default.utc(`${String(date2.year()).padStart(4, "0")}-01-01`, "YYYY-MM-DD", true);
         const dayOfYear = date2.diff(startOfYear, "day") + 1;
-        return date2.format(format3.replace(/D{3,4}/g, `[${String(dayOfYear).padStart(3, "0")}]`));
+        return date2.format(format4.replace(/D{3,4}/g, `[${String(dayOfYear).padStart(3, "0")}]`));
       }
       /**
        * Parses a date string with a dayjs format, as UTC. Single entry point for every date parse, so
@@ -44040,13 +44266,13 @@ var init_TypeCaster = __esm({
        * ever FORMAT with are rejected outright — non-strict parsing would otherwise read `2007305` as
        * 2007-01-05 rather than 2007-11-01 and report no error at all.
        */
-      parseDate(value, format3, strict = true) {
-        if (DAY_OF_YEAR_TOKEN.test(this._stripLiterals(format3)))
-          return this._parseDayOfYear(value, format3);
-        this._assertParsableFormat(format3);
-        const parsed = import_dayjs.default.utc(value, format3, strict);
+      parseDate(value, format4, strict = true) {
+        if (DAY_OF_YEAR_TOKEN.test(this._stripLiterals(format4)))
+          return this._parseDayOfYear(value, format4);
+        this._assertParsableFormat(format4);
+        const parsed = import_dayjs.default.utc(value, format4, strict);
         if (!parsed.isValid())
-          throw new Error(`Cannot parse "${value}" with input format "${format3}"`);
+          throw new Error(`Cannot parse "${value}" with input format "${format4}"`);
         return parsed;
       }
       /**
@@ -44055,61 +44281,61 @@ var init_TypeCaster = __esm({
        * walked token by token against the format — every token of such a format has a fixed width, so
        * a plain cursor is enough — and the date is then built from the year plus the ordinal offset.
        */
-      _parseDayOfYear(value, format3) {
+      _parseDayOfYear(value, format4) {
         const parts = {};
         let cursor = 0;
         let index = 0;
-        while (index < format3.length) {
-          if (format3[index] === "[") {
-            const close = format3.indexOf("]", index);
+        while (index < format4.length) {
+          if (format4[index] === "[") {
+            const close = format4.indexOf("]", index);
             if (close < 0)
-              throw new Error(`Unterminated "[" literal in date format "${format3}"`);
-            const literal2 = format3.slice(index + 1, close);
+              throw new Error(`Unterminated "[" literal in date format "${format4}"`);
+            const literal2 = format4.slice(index + 1, close);
             if (value.slice(cursor, cursor + literal2.length) !== literal2)
-              throw new Error(`Cannot parse "${value}" with input format "${format3}": expected "${literal2}" at character ${cursor + 1}`);
+              throw new Error(`Cannot parse "${value}" with input format "${format4}": expected "${literal2}" at character ${cursor + 1}`);
             cursor += literal2.length;
             index = close + 1;
             continue;
           }
-          const match = DATE_PARSE_TOKENS.find((x2) => format3.startsWith(x2.token, index));
+          const match = DATE_PARSE_TOKENS.find((x2) => format4.startsWith(x2.token, index));
           if (!match) {
-            if (/[A-Za-z]/.test(format3[index]))
-              throw new Error(`Date format "${format3}" mixes a day-of-year token with "${format3[index]}", which can't be parsed alongside it. Use YYYY/YY, DDD/DDDD, HH, mm, ss and SSS only.`);
-            if (value[cursor] !== format3[index])
-              throw new Error(`Cannot parse "${value}" with input format "${format3}": expected "${format3[index]}" at character ${cursor + 1}`);
+            if (/[A-Za-z]/.test(format4[index]))
+              throw new Error(`Date format "${format4}" mixes a day-of-year token with "${format4[index]}", which can't be parsed alongside it. Use YYYY/YY, DDD/DDDD, HH, mm, ss and SSS only.`);
+            if (value[cursor] !== format4[index])
+              throw new Error(`Cannot parse "${value}" with input format "${format4}": expected "${format4[index]}" at character ${cursor + 1}`);
             cursor++;
             index++;
             continue;
           }
           const digits = value.slice(cursor, cursor + match.width);
           if (digits.length !== match.width || !/^\d+$/.test(digits))
-            throw new Error(`Cannot parse "${value}" with input format "${format3}": expected ${match.width} digit(s) for "${match.token}" at character ${cursor + 1}`);
+            throw new Error(`Cannot parse "${value}" with input format "${format4}": expected ${match.width} digit(s) for "${match.token}" at character ${cursor + 1}`);
           parts[match.token] = Number(digits);
           cursor += match.width;
           index += match.token.length;
         }
         if (cursor !== value.length)
-          throw new Error(`Cannot parse "${value}" with input format "${format3}": ${value.length - cursor} unexpected trailing character(s)`);
+          throw new Error(`Cannot parse "${value}" with input format "${format4}": ${value.length - cursor} unexpected trailing character(s)`);
         const year2 = Algo_default.hasVal(parts["YYYY"]) ? parts["YYYY"] : parts["YY"];
         const dayOfYear = Algo_default.hasVal(parts["DDDD"]) ? parts["DDDD"] : parts["DDD"];
         if (!Algo_default.hasVal(year2))
-          throw new Error(`Date format "${format3}" declares a day of year but no year, so the date is ambiguous.`);
+          throw new Error(`Date format "${format4}" declares a day of year but no year, so the date is ambiguous.`);
         const startOfYear = import_dayjs.default.utc(`${String(year2).padStart(4, "0")}-01-01`, "YYYY-MM-DD", true);
         if (!startOfYear.isValid())
-          throw new Error(`Cannot parse "${value}" with input format "${format3}": "${year2}" is not a valid year`);
+          throw new Error(`Cannot parse "${value}" with input format "${format4}": "${year2}" is not a valid year`);
         const parsed = startOfYear.add(dayOfYear - 1, "day").add(parts["HH"] ?? 0, "hour").add(parts["mm"] ?? 0, "minute").add(parts["ss"] ?? 0, "second").add(parts["SSS"] ?? 0, "millisecond");
         if (dayOfYear < 1 || parsed.year() !== startOfYear.year())
-          throw new Error(`Cannot parse "${value}" with input format "${format3}": day of year ${dayOfYear} is outside year ${year2} (which has ${startOfYear.add(1, "year").diff(startOfYear, "day")} days)`);
+          throw new Error(`Cannot parse "${value}" with input format "${format4}": day of year ${dayOfYear} is outside year ${year2} (which has ${startOfYear.add(1, "year").diff(startOfYear, "day")} days)`);
         return parsed;
       }
-      _assertParsableFormat(format3) {
-        const stripped = this._stripLiterals(format3);
+      _assertParsableFormat(format4) {
+        const stripped = this._stripLiterals(format4);
         const offending = FORMAT_ONLY_TOKENS.find((token2) => stripped.includes(token2));
         if (offending)
-          throw new Error(`Date format "${format3}" uses the token "${offending}", which dayjs can only write, never read: parsing would silently produce the wrong date. Use a parseable token, or bracket it as a literal ("[${offending}]") if it is part of the text.`);
+          throw new Error(`Date format "${format4}" uses the token "${offending}", which dayjs can only write, never read: parsing would silently produce the wrong date. Use a parseable token, or bracket it as a literal ("[${offending}]") if it is part of the text.`);
       }
-      _stripLiterals(format3) {
-        return String(format3 ?? "").replace(/\[[^\]]*\]/g, "");
+      _stripLiterals(format4) {
+        return String(format4 ?? "").replace(/\[[^\]]*\]/g, "");
       }
     };
     TypeCaster = new TypeCasterClass();
@@ -44501,7 +44727,7 @@ var init_ProducerEngine = __esm({
 });
 
 // ../../packages/engines/src/ai/DeveloperEngine.ts
-var import_path14, import_promises11, import_dayjs2, import_customParseFormat2, DeveloperEngineClass, DeveloperEngine, DeveloperEngine_default;
+var import_path14, import_promises12, import_dayjs2, import_customParseFormat2, DeveloperEngineClass, DeveloperEngine, DeveloperEngine_default;
 var init_DeveloperEngine = __esm({
   "../../packages/engines/src/ai/DeveloperEngine.ts"() {
     init_src();
@@ -44509,7 +44735,7 @@ var init_DeveloperEngine = __esm({
     init_src4();
     init_src8();
     import_path14 = __toESM(require("path"), 1);
-    import_promises11 = __toESM(require("fs/promises"), 1);
+    import_promises12 = __toESM(require("fs/promises"), 1);
     import_dayjs2 = __toESM(require("dayjs"), 1);
     import_customParseFormat2 = __toESM(require("dayjs/plugin/customParseFormat"), 1);
     import_dayjs2.default.extend(import_customParseFormat2.default);
@@ -44539,8 +44765,8 @@ var init_DeveloperEngine = __esm({
           };
           mappedProducer["$schema"] = producer["$schema"];
           const producerPath = Environment_default.resolveResourceFilePath("producers", producer.name);
-          await import_promises11.default.mkdir(import_path14.default.dirname(producerPath), { recursive: true });
-          await import_promises11.default.writeFile(producerPath, JSON.stringify(mappedProducer, null, 4), "utf-8");
+          await import_promises12.default.mkdir(import_path14.default.dirname(producerPath), { recursive: true });
+          await import_promises12.default.writeFile(producerPath, JSON.stringify(mappedProducer, null, 4), "utf-8");
           return { producer: mappedProducer, fields: typeDefinitions };
         };
         // Discover-only precondition: sampling real data requires a configured, readable file.
@@ -47077,10 +47303,10 @@ var init_MockDataFactory = __esm({
 });
 
 // ../../packages/engines/src/mock/SyntheticInputEngine.ts
-var import_promises12, import_os, import_path15, import_dayjs4, import_customParseFormat3, import_utc3, POOL_CAP, SyntheticInputEngineClass, SyntheticInputEngine;
+var import_promises13, import_os, import_path15, import_dayjs4, import_customParseFormat3, import_utc3, POOL_CAP, SyntheticInputEngineClass, SyntheticInputEngine;
 var init_SyntheticInputEngine = __esm({
   "../../packages/engines/src/mock/SyntheticInputEngine.ts"() {
-    import_promises12 = __toESM(require("fs/promises"), 1);
+    import_promises13 = __toESM(require("fs/promises"), 1);
     import_os = __toESM(require("os"), 1);
     import_path15 = __toESM(require("path"), 1);
     import_dayjs4 = __toESM(require("dayjs"), 1);
@@ -47106,7 +47332,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_promises12.default.mkdtemp(import_path15.default.join(import_os.default.tmpdir(), "remora-synth-"));
+          const dir = await import_promises13.default.mkdtemp(import_path15.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));
@@ -47123,7 +47349,7 @@ var init_SyntheticInputEngine = __esm({
           return { inputs, dir };
         };
         this.cleanup = async (bundle) => {
-          if (bundle?.dir) await import_promises12.default.rm(bundle.dir, { recursive: true, force: true });
+          if (bundle?.dir) await import_promises13.default.rm(bundle.dir, { recursive: true, force: true });
         };
         this._assertOpts = (opts) => {
           Affirm_default(opts, "Invalid options");
@@ -47173,8 +47399,8 @@ var init_SyntheticInputEngine = __esm({
             lines.push(JSON.stringify(row) + "\n");
           }
           const filePath = import_path15.default.join(dir, `${producer.name}.jsonl`);
-          await import_promises12.default.writeFile(filePath, lines.join(""), "utf-8");
-          const { size } = await import_promises12.default.stat(filePath);
+          await import_promises13.default.writeFile(filePath, lines.join(""), "utf-8");
+          const { size } = await import_promises13.default.stat(filePath);
           return { path: filePath, fileSize: size };
         };
         // Distinct structured code sets referenced by these specs -> their records (deduped by name).
@@ -47285,7 +47511,7 @@ var init_SyntheticInputEngine = __esm({
         // True when a date bound names a day rather than an instant — neither the value nor the dimension's
         // format carries a time. Both have to agree: the value alone can't tell `"20240131"` from a compact
         // `YYYYMMDDHHmmss` instant, and the format alone can't tell that an ISO value overrode it.
-        this._isDayGranular = (value, format3) => !/[T ]\d{1,2}:/.test(value) && !/[HhmsSAa]/.test(format3 ?? "");
+        this._isDayGranular = (value, format4) => !/[T ]\d{1,2}:/.test(value) && !/[HhmsSAa]/.test(format4 ?? "");
         /**
          * One bound in the units the generator works in: the number itself, a count of characters for a
          * `string`, or epoch milliseconds for a `datetime`. A date bound is read with the dimension's own
@@ -48573,7 +48799,7 @@ var init_LineageRenderer = __esm({
 });
 
 // ../../packages/engines/src/lineage/ResourceView.ts
-var VISIBLE_AUTH_KEYS, MAX_TABLE_ROWS, MAX_RAW_BYTES, MAX_CELL_CHARS, ResourceViewClass, ResourceView, ResourceView_default;
+var VISIBLE_AUTH_KEYS, MAX_TABLE_ROWS, MAX_RAW_BYTES, MAX_CELL_CHARS, MAX_NOTE_CHARS, ResourceViewClass, ResourceView, ResourceView_default;
 var init_ResourceView = __esm({
   "../../packages/engines/src/lineage/ResourceView.ts"() {
     init_src();
@@ -48612,6 +48838,7 @@ var init_ResourceView = __esm({
     MAX_TABLE_ROWS = 500;
     MAX_RAW_BYTES = 256 * 1024;
     MAX_CELL_CHARS = 200;
+    MAX_NOTE_CHARS = 240;
     ResourceViewClass = class {
       constructor() {
         /**
@@ -48783,7 +49010,7 @@ var init_ResourceView = __esm({
             { key: "classification", label: "Classification" }
           ];
           const rows = dimensions.map((dimension) => [
-            { value: dimension.name },
+            { value: dimension.name, note: this._note(dimension.description) },
             { value: this._text(dimension.type) },
             positioned ? { value: this._position(dimension.position) } : { value: this._text(dimension.alias), muted: !dimension.alias },
             { value: !!dimension.pk, muted: !dimension.pk },
@@ -48795,7 +49022,7 @@ var init_ResourceView = __esm({
         };
         this._measuresTable = (producer) => {
           const rows = (producer.measures ?? []).map((measure) => [
-            { value: measure.name },
+            { value: measure.name, note: this._note(measure.description) },
             { value: measure.sql }
           ]);
           return this._table("Measures", [
@@ -48861,7 +49088,7 @@ var init_ResourceView = __esm({
         };
         this._consumerFieldsTable = (env2, consumer) => {
           const rows = (consumer.fields ?? []).map((field) => [
-            { value: field.key },
+            { value: field.key, note: this._note(field.description) },
             { value: this._text(field.alias), muted: !field.alias },
             { value: this._text(field.from), link: field.from ? this._inputLink(env2, field.from) : void 0, muted: !field.from },
             { value: this._text(field.transform ? Object.keys(field.transform) : null), muted: !field.transform },
@@ -48950,7 +49177,7 @@ var init_ResourceView = __esm({
           const required = new Set(schema.required ?? []);
           const properties = Object.entries(schema.properties ?? {});
           const rows = properties.map(([property, definition]) => [
-            { value: property },
+            { value: property, note: this._note(this._schemaKeyword(definition, "description")) },
             { value: this._schemaType(definition) },
             { value: required.has(property), muted: !required.has(property) },
             { value: this._text(this._schemaKeyword(definition, "format")), muted: !this._schemaKeyword(definition, "format") }
@@ -49056,6 +49283,15 @@ var init_ResourceView = __esm({
           const minutes = Math.floor(elapsedMS / 6e4);
           return `${minutes}m ${Math.round(elapsedMS % 6e4 / 1e3)}s`;
         };
+        /**
+         * A description as the secondary line of a cell. Blank prose is the same as none, so a field
+         * documented with a stray space does not cost the row a line.
+         */
+        this._note = (description) => {
+          const text = (description ?? "").trim();
+          if (!text) return void 0;
+          return text.length > MAX_NOTE_CHARS ? `${text.slice(0, MAX_NOTE_CHARS)}\u2026` : text;
+        };
         /** Anything that is not already a scalar becomes readable text; absent becomes `null`. */
         this._text = (value) => {
           if (value === void 0 || value === null) return null;
@@ -49660,7 +49896,7 @@ var init_OpsHeartbeat = __esm({
   "../../packages/engines/src/ops/OpsHeartbeat.ts"() {
     init_src2();
     init_OpsService();
-    DEFAULT_INTERVAL_MS = 6e4;
+    DEFAULT_INTERVAL_MS = 3e5;
     MIN_INTERVAL_MS = 5e3;
     MAX_INTERVAL_MS = 36e5;
     OpsHeartbeatClass = class {
@@ -49700,11 +49936,24 @@ var init_OpsHeartbeat = __esm({
             Logger_default.error(error);
           }
         };
+        /**
+         * Resolve the configured interval, in milliseconds. A value that is unusable or out of range is
+         * reported rather than silently replaced: an operator who set an interval and got a different
+         * one has no other way to find out.
+         */
         this.resolveInterval = () => {
-          const configured = Number(process.env.REMORA_STATE_INTERVAL_MS);
-          if (!Number.isFinite(configured) || configured <= 0)
+          const raw = process.env.REMORA_STATE_INTERVAL_MS;
+          if (!raw)
+            return DEFAULT_INTERVAL_MS;
+          const configured = Number(raw);
+          if (!Number.isFinite(configured) || configured <= 0) {
+            Logger_default.warn(`REMORA_STATE_INTERVAL_MS is not a positive number of milliseconds ("${raw}"); using ${DEFAULT_INTERVAL_MS}ms.`);
             return DEFAULT_INTERVAL_MS;
-          return Math.min(Math.max(configured, MIN_INTERVAL_MS), MAX_INTERVAL_MS);
+          }
+          const clamped = Math.min(Math.max(configured, MIN_INTERVAL_MS), MAX_INTERVAL_MS);
+          if (clamped !== configured)
+            Logger_default.warn(`REMORA_STATE_INTERVAL_MS of ${configured}ms is outside ${MIN_INTERVAL_MS}ms..${MAX_INTERVAL_MS}ms; using ${clamped}ms.`);
+          return clamped;
         };
       }
     };
@@ -50513,8 +50762,8 @@ var init_TransformationEngine = __esm({
             return result;
           }
           if ("cast" in transformations) {
-            const { cast, format: format3 } = transformations;
-            const casted = TypeCaster_default.cast(value, cast, format3);
+            const { cast, format: format4 } = transformations;
+            const casted = TypeCaster_default.cast(value, cast, format4);
             if (cast === "number" && isNaN(casted))
               throw new Error(`Cannot cast non-numeric value in field '${field.key}'`);
             if (cast === "datetime" && casted instanceof Date && isNaN(casted.getTime()))
@@ -51292,13 +51541,13 @@ var init_OutputExecutor = __esm({
 });
 
 // ../../packages/executors/src/ConsumerExecutor.ts
-var import_path18, import_fs13, import_readline6, import_promises13, import_crypto6, LIMIT_SCAN_BYTES, NEWLINE_BYTE, ConsumerExecutorClass, ConsumerExecutor, ConsumerExecutor_default;
+var import_path18, import_fs13, import_readline6, import_promises14, import_crypto6, LIMIT_SCAN_BYTES, NEWLINE_BYTE, ConsumerExecutorClass, ConsumerExecutor, ConsumerExecutor_default;
 var init_ConsumerExecutor = __esm({
   "../../packages/executors/src/ConsumerExecutor.ts"() {
     import_path18 = __toESM(require("path"));
     import_fs13 = __toESM(require("fs"));
     import_readline6 = __toESM(require("readline"));
-    import_promises13 = __toESM(require("fs/promises"));
+    import_promises14 = __toESM(require("fs/promises"));
     import_crypto6 = __toESM(require("crypto"));
     init_src10();
     init_src10();
@@ -51485,8 +51734,8 @@ var init_ConsumerExecutor = __esm({
               reader.destroy();
             });
           }
-          await import_promises13.default.unlink(datasetPath);
-          await import_promises13.default.rename(tempWorkPath, datasetPath);
+          await import_promises14.default.unlink(datasetPath);
+          await import_promises14.default.rename(tempWorkPath, datasetPath);
           return processedLineCount;
         };
         /**
@@ -51504,7 +51753,7 @@ var init_ConsumerExecutor = __esm({
         this.processLimit = async (datasetPath, limit) => {
           Affirm_default(datasetPath, "Invalid dataset path");
           Affirm_default(limit > 0, `Invalid record limit ${limit}`);
-          const handle = await import_promises13.default.open(datasetPath, "r+");
+          const handle = await import_promises14.default.open(datasetPath, "r+");
           try {
             const buffer = Buffer.allocUnsafe(LIMIT_SCAN_BYTES);
             let newlines = 0;
@@ -51558,8 +51807,8 @@ var init_ConsumerExecutor = __esm({
               reader.destroy();
             });
           }
-          await import_promises13.default.unlink(datasetPath);
-          await import_promises13.default.rename(tempWorkPath, datasetPath);
+          await import_promises14.default.unlink(datasetPath);
+          await import_promises14.default.rename(tempWorkPath, datasetPath);
           return newLineCount;
         };
         this.processDistinctOn = async (consumer, datasetPath) => {
@@ -51603,8 +51852,8 @@ var init_ConsumerExecutor = __esm({
               reader.destroy();
             });
           }
-          await import_promises13.default.unlink(datasetPath);
-          await import_promises13.default.rename(tempWorkPath, datasetPath);
+          await import_promises14.default.unlink(datasetPath);
+          await import_promises14.default.rename(tempWorkPath, datasetPath);
           return winners.size;
         };
         this.processPivot = async (consumer, datasetPath) => {
@@ -51710,12 +51959,12 @@ var init_ConsumerExecutor = __esm({
               reader.destroy();
             });
           }
-          await import_promises13.default.unlink(datasetPath);
-          await import_promises13.default.rename(tempWorkPath, datasetPath);
+          await import_promises14.default.unlink(datasetPath);
+          await import_promises14.default.rename(tempWorkPath, datasetPath);
           return outputCount;
         };
-        this._parseLine = (line, format3, fields) => {
-          return format3 === "CSV" ? LineParser_default._internalParseCSV(line, fields) : LineParser_default._internalParseJSON(line);
+        this._parseLine = (line, format4, fields) => {
+          return format4 === "CSV" ? LineParser_default._internalParseCSV(line, fields) : LineParser_default._internalParseJSON(line);
         };
         /**
          * Determines if the new record should replace the existing record based on the resolution strategy
@@ -52184,11 +52433,11 @@ var init_OrchestratorHelper = __esm({
 });
 
 // ../../packages/executors/src/LookupResolver.ts
-var import_fs15, import_promises14, import_path21, import_readline9, LookupResolverClass, LookupResolver, LookupResolver_default;
+var import_fs15, import_promises15, import_path21, import_readline9, LookupResolverClass, LookupResolver, LookupResolver_default;
 var init_LookupResolver = __esm({
   "../../packages/executors/src/LookupResolver.ts"() {
     import_fs15 = __toESM(require("fs"));
-    import_promises14 = __toESM(require("fs/promises"));
+    import_promises15 = __toESM(require("fs/promises"));
     import_path21 = __toESM(require("path"));
     import_readline9 = __toESM(require("readline"));
     init_src();
@@ -52229,11 +52478,11 @@ var init_LookupResolver = __esm({
               this.cache.set(id, await this.buildDict(lookupConsumer, capturePath, ref));
             }
             ExecutorScope_default.ensurePath(outPath);
-            await import_promises14.default.writeFile(outPath, JSON.stringify(this.cache.get(id)));
+            await import_promises15.default.writeFile(outPath, JSON.stringify(this.cache.get(id)));
             manifest.push({ id, consumer: ref.consumer, key: ref.key, value: ref.value, path: import_path21.default.resolve(outPath) });
           }
           for (const capturePath of captureByConsumer.values())
-            await import_promises14.default.rm(capturePath, { force: true });
+            await import_promises15.default.rm(capturePath, { force: true });
           return manifest;
         };
         // Runs the source consumer through the real pipeline, capturing its merged output before cleanup.
@@ -52251,7 +52500,7 @@ var init_LookupResolver = __esm({
         };
         // Projects the captured dataset to a { code: value } dict, bounded by MAX_LOOKUP_ROWS.
         this.buildDict = async (lookupConsumer, capturePath, ref) => {
-          const format3 = OutputExecutor_default._getInternalRecordFormat(lookupConsumer);
+          const format4 = OutputExecutor_default._getInternalRecordFormat(lookupConsumer);
           const visibleFields = ConsumerManager_default.getExpandedFields(lookupConsumer).filter((f7) => !f7.cField.hidden);
           const finalKeys = visibleFields.map((f7) => f7.finalKey);
           Affirm_default(finalKeys.includes(ref.key), `code_lookup key column "${ref.key}" is not in the output of consumer "${ref.consumer}"`);
@@ -52264,7 +52513,7 @@ var init_LookupResolver = __esm({
             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})`);
-            const record = this.parseLine(line, format3, visibleFields);
+            const record = this.parseLine(line, format4, visibleFields);
             const code = String(record[ref.key]);
             if (code in dict && !warnedDup) {
               Logger_default.warn(`code_lookup: duplicate key(s) in consumer "${ref.consumer}" for "${ref.key}"; last value wins`);
@@ -52275,8 +52524,8 @@ var init_LookupResolver = __esm({
           Logger_default.log(`[lookup] Built table "${ref.consumer}" (${ref.key}->${ref.value}): ${Object.keys(dict).length} entr(ies) from ${rowsRead} row(s)`);
           return dict;
         };
-        this.parseLine = (line, format3, visibleFields) => {
-          if (format3 === "CSV") return LineParser_default._internalParseCSV(line, visibleFields, ",");
+        this.parseLine = (line, format4, visibleFields) => {
+          if (format4 === "CSV") return LineParser_default._internalParseCSV(line, visibleFields, ",");
           return JSON.parse(line);
         };
         this.getCapturePath = (scope, consumerName) => {
@@ -52303,11 +52552,11 @@ var init_LookupResolver = __esm({
 });
 
 // ../../packages/executors/src/ConsumerInputResolver.ts
-var import_fs16, import_promises15, import_path22, ConsumerInputResolverClass, ConsumerInputResolver, ConsumerInputResolver_default;
+var import_fs16, import_promises16, import_path22, ConsumerInputResolverClass, ConsumerInputResolver, ConsumerInputResolver_default;
 var init_ConsumerInputResolver = __esm({
   "../../packages/executors/src/ConsumerInputResolver.ts"() {
     import_fs16 = __toESM(require("fs"));
-    import_promises15 = __toESM(require("fs/promises"));
+    import_promises16 = __toESM(require("fs/promises"));
     import_path22 = __toESM(require("path"));
     init_src();
     init_src3();
@@ -52338,7 +52587,7 @@ var init_ConsumerInputResolver = __esm({
               const capturePath = ExecutorScope_default.getConsumerInputPath(scope, name);
               ExecutorScope_default.ensurePath(capturePath);
               await this.runUpstreamConsumer(upstream, capturePath, stack, request);
-              const { size } = await import_promises15.default.stat(capturePath);
+              const { size } = await import_promises16.default.stat(capturePath);
               this.cache.set(name, { consumer: name, path: import_path22.default.resolve(capturePath), fileSize: size });
             }
             manifest.set(name, this.cache.get(name));
@@ -52401,11 +52650,11 @@ var ExecutorOrchestrator_exports = {};
 __export(ExecutorOrchestrator_exports, {
   default: () => ExecutorOrchestrator_default
 });
-var import_fs17, import_promises16, import_path23, import_readline10, import_workerpool, import_promises17, ExecutorOrchestratorClass, ExecutorOrchestrator, ExecutorOrchestrator_default;
+var import_fs17, import_promises17, import_path23, import_readline10, import_workerpool, import_promises18, ExecutorOrchestratorClass, ExecutorOrchestrator, ExecutorOrchestrator_default;
 var init_ExecutorOrchestrator = __esm({
   "../../packages/executors/src/ExecutorOrchestrator.ts"() {
     import_fs17 = __toESM(require("fs"));
-    import_promises16 = __toESM(require("fs/promises"));
+    import_promises17 = __toESM(require("fs/promises"));
     import_path23 = __toESM(require("path"));
     import_readline10 = __toESM(require("readline"));
     import_workerpool = __toESM(require("workerpool"));
@@ -52423,7 +52672,7 @@ var init_ExecutorOrchestrator = __esm({
     init_src();
     init_src10();
     init_ExecutorWriter();
-    import_promises17 = require("stream/promises");
+    import_promises18 = require("stream/promises");
     init_src2();
     init_ExecutorProgress2();
     init_src5();
@@ -52940,10 +53189,10 @@ 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_promises16.default.mkdir(import_path23.default.dirname(targetPath), { recursive: true });
+          await import_promises17.default.mkdir(import_path23.default.dirname(targetPath), { recursive: true });
           const internalFormat = OutputExecutor_default._getInternalRecordFormat(consumer);
           if (captureFormat !== "JSONL" || internalFormat !== "CSV") {
-            await import_promises16.default.copyFile(sourcePath, targetPath);
+            await import_promises17.default.copyFile(sourcePath, targetPath);
             return;
           }
           const visibleFields = fields.filter((field) => !field.cField.hidden);
@@ -53046,22 +53295,22 @@ var init_ExecutorOrchestrator = __esm({
                   startRow: prod.settings.startRow,
                   startColumn: prod.settings.startColumn
                 });
-                await (0, import_promises17.pipeline)(
+                await (0, import_promises18.pipeline)(
                   xlsCsvStream,
                   import_fs17.default.createWriteStream(decodedPath)
                 );
-                const fileStats = await import_promises16.default.stat(decodedPath);
+                const fileStats = await import_promises17.default.stat(decodedPath);
                 decodedFiles.push({ fullUri: decodedPath, fileSize: fileStats.size });
                 decodedCount++;
                 reportFile();
                 continue;
               }
               if (inferredType === "XML") {
-                const fileContent = await import_promises16.default.readFile(file.fullUri, "utf-8");
+                const fileContent = await import_promises17.default.readFile(file.fullUri, "utf-8");
                 const jsonData = XMLParser_default.xmlToJson(fileContent);
                 const records = normalizeXmlRows(jsonData);
                 if (records.length === 0) {
-                  await import_promises16.default.writeFile(decodedPath, "", "utf-8");
+                  await import_promises17.default.writeFile(decodedPath, "", "utf-8");
                 } else {
                   const columns = [];
                   for (const record of records) {
@@ -53077,9 +53326,9 @@ var init_ExecutorOrchestrator = __esm({
                     const row = columns.map((column) => csvSafeValue(record[column]));
                     lines.push(CSVParser_default.stringifyRow(row));
                   }
-                  await import_promises16.default.writeFile(decodedPath, lines.join("\n"), "utf-8");
+                  await import_promises17.default.writeFile(decodedPath, lines.join("\n"), "utf-8");
                 }
-                const fileStats = await import_promises16.default.stat(decodedPath);
+                const fileStats = await import_promises17.default.stat(decodedPath);
                 decodedFiles.push({ fullUri: decodedPath, fileSize: fileStats.size });
                 decodedCount++;
                 reportFile();
@@ -53107,20 +53356,20 @@ var init_ExecutorOrchestrator = __esm({
             Logger_default.log(`[${scope.id}] Merging ${executorResults.length} worker output files into ${mainPath}`);
             const perf = performance.now();
             for (const workerResult of executorResults) {
-              await (0, import_promises17.pipeline)(
+              await (0, import_promises18.pipeline)(
                 import_fs17.default.createReadStream(workerResult.resultUri),
                 import_fs17.default.createWriteStream(mainPath, { flags: "a" })
               );
-              await import_promises16.default.unlink(workerResult.resultUri);
+              await import_promises17.default.unlink(workerResult.resultUri);
             }
             tracker.measure("merge-workers", performance.now() - perf);
             Logger_default.log(`[${scope.id}] Merge complete in ${Math.round(performance.now() - perf)}ms`);
           } else if (executorResults.length === 1) {
             Logger_default.log(`[${scope.id}] Single worker \u2014 renaming output to ${mainPath}`);
-            await import_promises16.default.rename(executorResults[0].resultUri, mainPath);
+            await import_promises17.default.rename(executorResults[0].resultUri, mainPath);
           } else {
             Logger_default.log(`[${scope.id}] No worker output \u2014 writing an empty dataset to ${mainPath}`);
-            await import_promises16.default.writeFile(mainPath, "");
+            await import_promises17.default.writeFile(mainPath, "");
           }
           return mainPath;
         };
@@ -53538,6 +53787,7 @@ var runExecutorTask = async (workerData) => {
   Logger_default.initFromEnv();
   if (workerData.loggerConfig)
     Logger_default.initFromConfig(workerData.loggerConfig);
+  Logger_default.captureConsole();
   const envLoadMS = prepareEnvironment();
   try {
     const {
@@ -53597,7 +53847,7 @@ init_ProducerExecutor();
 
 // ../../packages/executors/src/SampleRunner.ts
 var import_fs18 = __toESM(require("fs"));
-var import_promises18 = __toESM(require("fs/promises"));
+var import_promises19 = __toESM(require("fs/promises"));
 var import_path24 = __toESM(require("path"));
 var import_readline11 = __toESM(require("readline"));
 init_src();
@@ -53671,7 +53921,7 @@ var SampleRunnerClass = class {
           note: `${records.length} row(s) from the real pipeline \u2014 filters, transformations, masking and validation all applied, exactly as in a run. Nothing was written to the destination.`
         };
       } finally {
-        await import_promises18.default.rm(capturePath, { force: true });
+        await import_promises19.default.rm(capturePath, { force: true });
       }
     };
     /**