@forzalabs/remora 2.0.1 → 2.0.3

package/workers/ExecutorWorker.js

@@ -7807,15 +7807,15 @@ var require_index_cjs = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path20 = [graph[toModel].parent, toModel];
+      const path21 = [graph[toModel].parent, toModel];
       let fn = convert$1[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path20.unshift(graph[cur].parent);
+        path21.unshift(graph[cur].parent);
         fn = link(convert$1[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path20;
+      fn.conversion = path21;
       return fn;
     }
     function route(fromModel) {
@@ -8445,7 +8445,7 @@ var require_node2 = __commonJS({
 var require_tail_file = __commonJS({
   "../../node_modules/winston/lib/winston/tail-file.js"(exports2, module2) {
     "use strict";
-    var fs23 = require("fs");
+    var fs24 = require("fs");
     var { StringDecoder } = require("string_decoder");
     var { Stream } = require_readable();
     function noop() {
@@ -8466,7 +8466,7 @@ var require_tail_file = __commonJS({
         stream.emit("end");
         stream.emit("close");
       };
-      fs23.open(options.file, "a+", "0644", (err2, fd) => {
+      fs24.open(options.file, "a+", "0644", (err2, fd) => {
         if (err2) {
           if (!iter) {
             stream.emit("error", err2);
@@ -8478,10 +8478,10 @@ var require_tail_file = __commonJS({
         }
         (function read() {
           if (stream.destroyed) {
-            fs23.close(fd, noop);
+            fs24.close(fd, noop);
             return;
           }
-          return fs23.read(fd, buffer, 0, buffer.length, pos, (error, bytes) => {
+          return fs24.read(fd, buffer, 0, buffer.length, pos, (error, bytes) => {
             if (error) {
               if (!iter) {
                 stream.emit("error", error);
@@ -8540,8 +8540,8 @@ var require_tail_file = __commonJS({
 var require_file = __commonJS({
   "../../node_modules/winston/lib/winston/transports/file.js"(exports2, module2) {
     "use strict";
-    var fs23 = require("fs");
-    var path20 = require("path");
+    var fs24 = require("fs");
+    var path21 = require("path");
     var asyncSeries = require_series();
     var zlib3 = require("zlib");
     var { MESSAGE } = require_triple_beam();
@@ -8571,14 +8571,14 @@ var require_file = __commonJS({
         this._onError = this._onError.bind(this);
         if (options.filename || options.dirname) {
           throwIf("filename or dirname", "stream");
-          this._basename = this.filename = options.filename ? path20.basename(options.filename) : "winston.log";
-          this.dirname = options.dirname || path20.dirname(options.filename);
+          this._basename = this.filename = options.filename ? path21.basename(options.filename) : "winston.log";
+          this.dirname = options.dirname || path21.dirname(options.filename);
           this.options = options.options || { flags: "a" };
         } else if (options.stream) {
           console.warn("options.stream will be removed in winston@4. Use winston.transports.Stream");
           throwIf("stream", "filename", "maxsize");
           this._dest = this._stream.pipe(this._setupStream(options.stream));
-          this.dirname = path20.dirname(this._dest.path);
+          this.dirname = path21.dirname(this._dest.path);
         } else {
           throw new Error("Cannot log to file without filename or stream.");
         }
@@ -8741,11 +8741,11 @@ var require_file = __commonJS({
           options = {};
         }
         options = normalizeQuery(options);
-        const file = path20.join(this.dirname, this.filename);
+        const file = path21.join(this.dirname, this.filename);
         let buff = "";
         let results = [];
         let row = 0;
-        const stream = fs23.createReadStream(file, {
+        const stream = fs24.createReadStream(file, {
           encoding: "utf8"
         });
         stream.on("error", (err2) => {
@@ -8846,7 +8846,7 @@ var require_file = __commonJS({
        * TODO: Refactor me.
        */
       stream(options = {}) {
-        const file = path20.join(this.dirname, this.filename);
+        const file = path21.join(this.dirname, this.filename);
         const stream = new Stream();
         const tail = {
           file,
@@ -8896,8 +8896,8 @@ var require_file = __commonJS({
        */
       stat(callback) {
         const target = this._getFile();
-        const fullpath = path20.join(this.dirname, target);
-        fs23.stat(fullpath, (err2, stat) => {
+        const fullpath = path21.join(this.dirname, target);
+        fs24.stat(fullpath, (err2, stat) => {
           if (err2 && err2.code === "ENOENT") {
             debug("ENOENT\xA0ok", fullpath);
             this.filename = target;
@@ -9000,9 +9000,9 @@ var require_file = __commonJS({
        * @returns {WritableStream} Stream that writes to disk for the active file.
        */
       _createStream(source) {
-        const fullpath = path20.join(this.dirname, this.filename);
+        const fullpath = path21.join(this.dirname, this.filename);
         debug("create stream start", fullpath, this.options);
-        const dest = fs23.createWriteStream(fullpath, this.options).on("error", (err2) => debug(err2)).on("close", () => debug("close", dest.path, dest.bytesWritten)).on("open", () => {
+        const dest = fs24.createWriteStream(fullpath, this.options).on("error", (err2) => debug(err2)).on("close", () => debug("close", dest.path, dest.bytesWritten)).on("open", () => {
           debug("file open ok", fullpath);
           this.emit("open", fullpath);
           source.pipe(dest);
@@ -9025,16 +9025,16 @@ var require_file = __commonJS({
        */
       _incFile(callback) {
         debug("_incFile", this.filename);
-        const ext = path20.extname(this._basename);
-        const basename = path20.basename(this._basename, ext);
+        const ext = path21.extname(this._basename);
+        const basename = path21.basename(this._basename, ext);
         const tasks = [];
         if (this.zippedArchive) {
           tasks.push(
             function(cb) {
               const num = this._created > 0 && !this.tailable ? this._created : "";
               this._compressFile(
-                path20.join(this.dirname, `${basename}${num}${ext}`),
-                path20.join(this.dirname, `${basename}${num}${ext}.gz`),
+                path21.join(this.dirname, `${basename}${num}${ext}`),
+                path21.join(this.dirname, `${basename}${num}${ext}.gz`),
                 cb
               );
             }.bind(this)
@@ -9059,8 +9059,8 @@ var require_file = __commonJS({
        * @private
        */
       _getFile() {
-        const ext = path20.extname(this._basename);
-        const basename = path20.basename(this._basename, ext);
+        const ext = path21.extname(this._basename);
+        const basename = path21.basename(this._basename, ext);
         const isRotation = this.rotationFormat ? this.rotationFormat() : this._created;
         return !this.tailable && this._created ? `${basename}${isRotation}${ext}` : `${basename}${ext}`;
       }
@@ -9080,8 +9080,8 @@ var require_file = __commonJS({
         const isOldest = oldest !== 0 ? oldest : "";
         const isZipped = this.zippedArchive ? ".gz" : "";
         const filePath = `${basename}${isOldest}${ext}${isZipped}`;
-        const target = path20.join(this.dirname, filePath);
-        fs23.unlink(target, callback);
+        const target = path21.join(this.dirname, filePath);
+        fs24.unlink(target, callback);
       }
       /**
        * Roll files forward based on integer, up to maxFiles. e.g. if base if
@@ -9103,20 +9103,20 @@ var require_file = __commonJS({
         for (let x2 = this.maxFiles - 1; x2 > 1; x2--) {
           tasks.push(function(i6, cb) {
             let fileName = `${basename}${i6 - 1}${ext}${isZipped}`;
-            const tmppath = path20.join(this.dirname, fileName);
-            fs23.exists(tmppath, (exists) => {
+            const tmppath = path21.join(this.dirname, fileName);
+            fs24.exists(tmppath, (exists) => {
               if (!exists) {
                 return cb(null);
               }
               fileName = `${basename}${i6}${ext}${isZipped}`;
-              fs23.rename(tmppath, path20.join(this.dirname, fileName), cb);
+              fs24.rename(tmppath, path21.join(this.dirname, fileName), cb);
             });
           }.bind(this, x2));
         }
         asyncSeries(tasks, () => {
-          fs23.rename(
-            path20.join(this.dirname, `${basename}${ext}${isZipped}`),
-            path20.join(this.dirname, `${basename}1${ext}${isZipped}`),
+          fs24.rename(
+            path21.join(this.dirname, `${basename}${ext}${isZipped}`),
+            path21.join(this.dirname, `${basename}1${ext}${isZipped}`),
             callback
           );
         });
@@ -9130,22 +9130,22 @@ var require_file = __commonJS({
        * @private
        */
       _compressFile(src, dest, callback) {
-        fs23.access(src, fs23.F_OK, (err2) => {
+        fs24.access(src, fs24.F_OK, (err2) => {
           if (err2) {
             return callback();
           }
           var gzip = zlib3.createGzip();
-          var inp = fs23.createReadStream(src);
-          var out = fs23.createWriteStream(dest);
+          var inp = fs24.createReadStream(src);
+          var out = fs24.createWriteStream(dest);
           out.on("finish", () => {
-            fs23.unlink(src, callback);
+            fs24.unlink(src, callback);
           });
           inp.pipe(gzip).pipe(out);
         });
       }
       _createLogDirIfNotExist(dirPath) {
-        if (!fs23.existsSync(dirPath)) {
-          fs23.mkdirSync(dirPath, { recursive: true });
+        if (!fs24.existsSync(dirPath)) {
+          fs24.mkdirSync(dirPath, { recursive: true });
         }
       }
     };
@@ -9229,9 +9229,9 @@ var require_http = __commonJS({
         };
         const auth = options.params.auth || null;
         delete options.params.auth;
-        const path20 = options.params.path || null;
+        const path21 = options.params.path || null;
         delete options.params.path;
-        this._request(options, auth, path20, (err2, res, body) => {
+        this._request(options, auth, path21, (err2, res, body) => {
           if (res && res.statusCode !== 200) {
             err2 = new Error(`Invalid HTTP Status Code: ${res.statusCode}`);
           }
@@ -9259,12 +9259,12 @@ var require_http = __commonJS({
           method: "stream",
           params: options
         };
-        const path20 = options.params.path || null;
+        const path21 = options.params.path || null;
         delete options.params.path;
         const auth = options.params.auth || null;
         delete options.params.auth;
         let buff = "";
-        const req = this._request(options, auth, path20);
+        const req = this._request(options, auth, path21);
         stream.destroy = () => req.destroy();
         req.on("data", (data) => {
           data = (buff + data).split(/\n+/);
@@ -9290,14 +9290,14 @@ var require_http = __commonJS({
        * @param {string} path - request path
        * @param {function} callback - Continuation to respond to when complete.
        */
-      _request(options, auth, path20, callback) {
+      _request(options, auth, path21, callback) {
         options = options || {};
         auth = auth || this.auth;
-        path20 = path20 || this.path || "";
+        path21 = path21 || this.path || "";
         if (this.batch) {
-          this._doBatch(options, callback, auth, path20);
+          this._doBatch(options, callback, auth, path21);
         } else {
-          this._doRequest(options, callback, auth, path20);
+          this._doRequest(options, callback, auth, path21);
         }
       }
       /**
@@ -9307,18 +9307,18 @@ var require_http = __commonJS({
        * @param {Object?} auth - authentication options
        * @param {string} path - request path
        */
-      _doBatch(options, callback, auth, path20) {
+      _doBatch(options, callback, auth, path21) {
         this.batchOptions.push(options);
         if (this.batchOptions.length === 1) {
           const me3 = this;
           this.batchCallback = callback;
           this.batchTimeoutID = setTimeout(function() {
             me3.batchTimeoutID = -1;
-            me3._doBatchRequest(me3.batchCallback, auth, path20);
+            me3._doBatchRequest(me3.batchCallback, auth, path21);
           }, this.batchInterval);
         }
         if (this.batchOptions.length === this.batchCount) {
-          this._doBatchRequest(this.batchCallback, auth, path20);
+          this._doBatchRequest(this.batchCallback, auth, path21);
         }
       }
       /**
@@ -9327,14 +9327,14 @@ var require_http = __commonJS({
        * @param {Object?} auth - authentication options
        * @param {string} path - request path
        */
-      _doBatchRequest(callback, auth, path20) {
+      _doBatchRequest(callback, auth, path21) {
         if (this.batchTimeoutID > 0) {
           clearTimeout(this.batchTimeoutID);
           this.batchTimeoutID = -1;
         }
         const batchOptionsCopy = this.batchOptions.slice();
         this.batchOptions = [];
-        this._doRequest(batchOptionsCopy, callback, auth, path20);
+        this._doRequest(batchOptionsCopy, callback, auth, path21);
       }
       /**
        * Make a request to a winstond server or any http server which can
@@ -9344,7 +9344,7 @@ var require_http = __commonJS({
        * @param {Object?} auth - authentication options
        * @param {string} path - request path
        */
-      _doRequest(options, callback, auth, path20) {
+      _doRequest(options, callback, auth, path21) {
         const headers = Object.assign({}, this.headers);
         if (auth && auth.bearer) {
           headers.Authorization = `Bearer ${auth.bearer}`;
@@ -9354,7 +9354,7 @@ var require_http = __commonJS({
           method: "POST",
           host: this.host,
           port: this.port,
-          path: `/${path20.replace(/^\//, "")}`,
+          path: `/${path21.replace(/^\//, "")}`,
           headers,
           auth: auth && auth.username && auth.password ? `${auth.username}:${auth.password}` : "",
           agent: this.agent
@@ -11575,7 +11575,7 @@ var CONSTANTS, Constants_default;
 var init_Constants = __esm({
   "../../packages/constants/src/Constants.ts"() {
     CONSTANTS = {
-      cliVersion: "2.0.1",
+      cliVersion: "2.0.3",
       backendVersion: 1,
       backendPort: 5088,
       workerVersion: 2,
@@ -11632,7 +11632,12 @@ var init_Constants = __esm({
          * whole run, so the entire work list is submitted at once and needs an upper bound. A queued
          * task holds references, not copies, so this bounds the work list rather than memory.
          */
-        MAX_WORKER_QUEUE_SIZE: 1e5
+        MAX_WORKER_QUEUE_SIZE: 1e5,
+        /**
+         * Rows a sample may ask for out of the pipeline. A sample is a look at the data, never an
+         * export of it — `remora sample -s` and the preview's Data tab are both held to this.
+         */
+        MAX_SAMPLE_ROWS: 100
       }
     };
     Constants_default = CONSTANTS;
@@ -12780,7 +12785,7 @@ var init_Validator = __esm({
          */
         this.detectOnFinishRecursion = (consumer) => {
           const errors = [];
-          const path20 = [];
+          const path21 = [];
           const targetsOf = (cons) => {
             const names = [];
             for (const output of cons.outputs ?? []) {
@@ -12792,17 +12797,17 @@ var init_Validator = __esm({
             return names;
           };
           const walk = (name) => {
-            if (path20.some((x2) => x2.toLowerCase() === name.toLowerCase())) {
-              errors.push(`Consumer "${consumer.name}" has a cyclic run-consumer (onSuccess/onError) chain: ${[...path20, name].join(" -> ")}`);
+            if (path21.some((x2) => x2.toLowerCase() === name.toLowerCase())) {
+              errors.push(`Consumer "${consumer.name}" has a cyclic run-consumer (onSuccess/onError) chain: ${[...path21, name].join(" -> ")}`);
               return true;
             }
             const cons = Environment_default.getConsumer(name);
             if (!cons) return false;
-            path20.push(name);
+            path21.push(name);
             for (const target of targetsOf(cons)) {
               if (walk(target)) return true;
             }
-            path20.pop();
+            path21.pop();
             return false;
           };
           walk(consumer.name);
@@ -14852,14 +14857,14 @@ var init_readFile = __esm({
     import_promises3 = require("fs/promises");
     filePromises = {};
     fileIntercept = {};
-    readFile2 = (path20, options) => {
-      if (fileIntercept[path20] !== void 0) {
-        return fileIntercept[path20];
+    readFile2 = (path21, options) => {
+      if (fileIntercept[path21] !== void 0) {
+        return fileIntercept[path21];
       }
-      if (!filePromises[path20] || options?.ignoreCache) {
-        filePromises[path20] = (0, import_promises3.readFile)(path20, "utf8");
+      if (!filePromises[path21] || options?.ignoreCache) {
+        filePromises[path21] = (0, import_promises3.readFile)(path21, "utf8");
       }
-      return filePromises[path20];
+      return filePromises[path21];
     };
   }
 });
@@ -14971,8 +14976,8 @@ var init_externalDataInterceptor = __esm({
       getFileRecord() {
         return fileIntercept;
       },
-      interceptFile(path20, contents) {
-        fileIntercept[path20] = Promise.resolve(contents);
+      interceptFile(path21, contents) {
+        fileIntercept[path21] = Promise.resolve(contents);
       },
       getTokenRecord() {
         return tokenIntercept;
@@ -18052,8 +18057,8 @@ var init_createConfigValueProvider = __esm({
               return endpoint.url.href;
             }
             if ("hostname" in endpoint) {
-              const { protocol, hostname, port, path: path20 } = endpoint;
-              return `${protocol}//${hostname}${port ? ":" + port : ""}${path20}`;
+              const { protocol, hostname, port, path: path21 } = endpoint;
+              return `${protocol}//${hostname}${port ? ":" + port : ""}${path21}`;
             }
           }
           return endpoint;
@@ -18428,18 +18433,18 @@ var getAttrPathList;
 var init_getAttrPathList = __esm({
   "../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/getAttrPathList.js"() {
     init_types2();
-    getAttrPathList = (path20) => {
-      const parts = path20.split(".");
+    getAttrPathList = (path21) => {
+      const parts = path21.split(".");
       const pathList = [];
       for (const part of parts) {
         const squareBracketIndex = part.indexOf("[");
         if (squareBracketIndex !== -1) {
           if (part.indexOf("]") !== part.length - 1) {
-            throw new EndpointError(`Path: '${path20}' does not end with ']'`);
+            throw new EndpointError(`Path: '${path21}' does not end with ']'`);
           }
           const arrayIndex = part.slice(squareBracketIndex + 1, -1);
           if (Number.isNaN(parseInt(arrayIndex))) {
-            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path20}'`);
+            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path21}'`);
           }
           if (squareBracketIndex !== 0) {
             pathList.push(part.slice(0, squareBracketIndex));
@@ -18460,9 +18465,9 @@ var init_getAttr = __esm({
   "../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/getAttr.js"() {
     init_types2();
     init_getAttrPathList();
-    getAttr = (value, path20) => getAttrPathList(path20).reduce((acc, index) => {
+    getAttr = (value, path21) => getAttrPathList(path21).reduce((acc, index) => {
       if (typeof acc !== "object") {
-        throw new EndpointError(`Index '${index}' in '${path20}' not found in '${JSON.stringify(value)}'`);
+        throw new EndpointError(`Index '${index}' in '${path21}' not found in '${JSON.stringify(value)}'`);
       } else if (Array.isArray(acc)) {
         const i6 = parseInt(index);
         return acc[i6 < 0 ? acc.length + i6 : i6];
@@ -18523,8 +18528,8 @@ var init_parseURL = __esm({
             return value;
           }
           if (typeof value === "object" && "hostname" in value) {
-            const { hostname: hostname2, port, protocol: protocol2 = "", path: path20 = "", query = {} } = value;
-            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path20}`);
+            const { hostname: hostname2, port, protocol: protocol2 = "", path: path21 = "", query = {} } = value;
+            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path21}`);
             url.search = Object.entries(query).map(([k7, v3]) => `${k7}=${v3}`).join("&");
             return url;
           }
@@ -20868,11 +20873,11 @@ var init_HttpBindingProtocol = __esm({
           const opTraits = translateTraits(operationSchema.traits);
           if (opTraits.http) {
             request.method = opTraits.http[0];
-            const [path20, search] = opTraits.http[1].split("?");
+            const [path21, search] = opTraits.http[1].split("?");
             if (request.path == "/") {
-              request.path = path20;
+              request.path = path21;
             } else {
-              request.path += path20;
+              request.path += path21;
             }
             const traitSearchParams = new URLSearchParams(search ?? "");
             for (const [key, value] of traitSearchParams) {
@@ -24585,12 +24590,12 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             const password = request.password ?? "";
             auth = `${username}:${password}`;
           }
-          let path20 = request.path;
+          let path21 = request.path;
           if (queryString) {
-            path20 += `?${queryString}`;
+            path21 += `?${queryString}`;
           }
           if (request.fragment) {
-            path20 += `#${request.fragment}`;
+            path21 += `#${request.fragment}`;
           }
           let hostname = request.hostname ?? "";
           if (hostname[0] === "[" && hostname.endsWith("]")) {
@@ -24602,7 +24607,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             headers: request.headers,
             host: hostname,
             method: request.method,
-            path: path20,
+            path: path21,
             port: request.port,
             agent,
             auth
@@ -25511,10 +25516,10 @@ ${longDate}
 ${credentialScope}
 ${toHex(hashedRequest)}`;
       }
-      getCanonicalPath({ path: path20 }) {
+      getCanonicalPath({ path: path21 }) {
         if (this.uriEscapePath) {
           const normalizedPathSegments = [];
-          for (const pathSegment of path20.split("/")) {
+          for (const pathSegment of path21.split("/")) {
             if (pathSegment?.length === 0)
               continue;
             if (pathSegment === ".")
@@ -25525,11 +25530,11 @@ ${toHex(hashedRequest)}`;
               normalizedPathSegments.push(pathSegment);
             }
           }
-          const normalizedPath = `${path20?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path20?.endsWith("/") ? "/" : ""}`;
+          const normalizedPath = `${path21?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path21?.endsWith("/") ? "/" : ""}`;
           const doubleEncoded = escapeUri(normalizedPath);
           return doubleEncoded.replace(/%2F/g, "/");
         }
-        return path20;
+        return path21;
       }
       validateResolvedCredentials(credentials) {
         if (typeof credentials !== "object" || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string") {
@@ -42802,8 +42807,8 @@ var init_HttpClient = __esm({
             throw new Error(err2.message ?? "An error occurred on GET.");
           }
         };
-        this.getWorkerUrl = (path20) => {
-          const cleanPath = path20.startsWith("/") ? path20.substring(1) : path20;
+        this.getWorkerUrl = (path21) => {
+          const cleanPath = path21.startsWith("/") ? path21.substring(1) : path21;
           return `${this.workerHost}/${cleanPath}`;
         };
         this.workerHost = ProcessENVManager_default.getEnvVariable("REMORA_WORKER_HOST") || "http://worker:5069";
@@ -42949,32 +42954,32 @@ var init_DriverHelper = __esm({
       },
       quickReadFile: async (filePath, lineCount) => {
         const fileStream = (0, import_fs9.createReadStream)(filePath);
-        const rl7 = (0, import_readline.createInterface)({ input: fileStream, crlfDelay: Infinity });
+        const rl8 = (0, import_readline.createInterface)({ input: fileStream, crlfDelay: Infinity });
         const lines = [];
         let counter = 0;
-        for await (const line of rl7) {
+        for await (const line of rl8) {
           lines.push(line);
           counter++;
           if (counter >= lineCount) {
             break;
           }
         }
-        rl7.close();
+        rl8.close();
         fileStream.close();
         return lines;
       },
       quickReadStream: async (stream, lineCount) => {
-        const rl7 = (0, import_readline.createInterface)({ input: stream, crlfDelay: Infinity });
+        const rl8 = (0, import_readline.createInterface)({ input: stream, crlfDelay: Infinity });
         const lines = [];
         let counter = 0;
-        for await (const line of rl7) {
+        for await (const line of rl8) {
           lines.push(line);
           counter++;
           if (counter >= lineCount) {
             break;
           }
         }
-        rl7.close();
+        rl8.close();
         return lines;
       }
     };
@@ -43748,7 +43753,7 @@ var init_S3DestinationDriver = __esm({
 });
 
 // ../../packages/drivers/src/DriverFactory.ts
-var DriverFactoryClass, DriverFactory, DriverFactory_default;
+var STAGEABLE_ENGINES, DriverFactoryClass, DriverFactory, DriverFactory_default;
 var init_DriverFactory = __esm({
   "../../packages/drivers/src/DriverFactory.ts"() {
     init_RedshiftDriver();
@@ -43758,8 +43763,11 @@ var init_DriverFactory = __esm({
     init_LocalDestinationDriver();
     init_S3SourceDriver();
     init_S3DestinationDriver();
+    STAGEABLE_ENGINES = ["local", "aws-s3", "delta-share"];
     DriverFactoryClass = class {
       constructor() {
+        /** Whether a run can stage a producer from this engine — see `STAGEABLE_ENGINES`. */
+        this.canStage = (engine) => STAGEABLE_ENGINES.includes(engine);
         this.instantiateSource = async (source) => {
           switch (source.engine) {
             case "aws-redshift": {
@@ -43839,6 +43847,7 @@ var init_ProducerManager = __esm({
     init_src4();
     init_src3();
     init_src5();
+    init_CryptoEngine();
     ProducerManagerClass = class {
       constructor() {
         this.getColumns = (producer) => {
@@ -43893,6 +43902,46 @@ var init_ProducerManager = __esm({
             return true;
           return FixedWidthParser_default.matchesSelector(line, resolved.selector, resolved.range);
         };
+        /**
+         * The post-parse work a producer implies for every record it produces: which keys carry the
+         * source file name, and which carry a mask.
+         *
+         * Resolved once per chunk, never per line — `getMask` resolves a secret and validates the value,
+         * and neither depends on the record. Empty for almost every producer, which is the case worth
+         * keeping fast.
+         */
+        this.compileFills = (dimensions) => {
+          Affirm_default(dimensions, "Invalid producer dimensions");
+          const fills = [];
+          for (const dimension of dimensions) {
+            const { prodDimension } = dimension;
+            const mask = this.getMask(prodDimension);
+            const sourceFilename = prodDimension.sourceFilename === true;
+            if (!sourceFilename && !Algo_default.hasVal(mask))
+              continue;
+            fills.push({ key: dimension.name, mask, sourceFilename, type: prodDimension.type });
+          }
+          return fills;
+        };
+        /**
+         * Applies the compiled fills to one parsed record, in place.
+         *
+         * The one place a producer dimension's mask is ever applied, on purpose: a run reaches it through
+         * `ProducerExecutor.processLine` and a sample through `ProducerEngine`, and a masked dimension
+         * that came back in the clear from one of the two would be a `hash` the project declared and the
+         * screen ignored — a disclosure, not a display bug.
+         */
+        this.applyFills = (record, fills, sourceFilename) => {
+          if (!fills?.length)
+            return record;
+          for (const fill2 of fills) {
+            if (fill2.sourceFilename)
+              record[fill2.key] = sourceFilename;
+            if (Algo_default.hasVal(fill2.mask))
+              record[fill2.key] = CryptoEngine_default.hashValue(fill2.mask, record[fill2.key]?.toString(), fill2.type);
+          }
+          return record;
+        };
       }
     };
     ProducerManager = new ProducerManagerClass();
@@ -44307,7 +44356,8 @@ var init_ProducerEngine = __esm({
                     }
                   };
                 }
-                const fileData = await this.readFile(effectiveProducer, { readmode: "lines", lines: { from: 0, to: sampleSize } }, effectiveSource);
+                const headerLines = ParseHelper_default.hasHeaderLine(effectiveProducer.settings.fileType, effectiveProducer.settings.hasHeaderRow) ? 1 : 0;
+                const fileData = await this.readFile(effectiveProducer, { readmode: "lines", lines: { from: 0, to: sampleSize + headerLines } }, effectiveSource);
                 rawData = fileData.data;
               } finally {
                 if (scope)
@@ -44326,13 +44376,15 @@ var init_ProducerEngine = __esm({
           if (!rawData || rawData.length === 0) return [];
           const firstItem = rawData[0];
           const isLineData = typeof firstItem === "string";
+          const fills = discover ? [] : ProducerManager_default.compileFills(this._fillDimensions(producer));
+          const sourceFilename = import_path13.default.basename(producer.settings.fileKey ?? producer.settings.sqlTable ?? "");
           if (isLineData) {
             const lines = rawData;
             const dimensions = this.deriveDimensions(lines[0], producer, discover);
             const { fileType, hasHeaderRow } = producer.settings;
             const dataLines = ParseHelper_default.hasHeaderLine(fileType, hasHeaderRow) ? lines.slice(1) : lines;
             const recordSelector = ProducerManager_default.resolveRecordSelector(producer);
-            return dataLines.filter((line) => line.trim().length > 0).filter((line) => ProducerManager_default.shouldReadLine(line, recordSelector)).flatMap((line) => LineParser_default.parseAll(line, producer, dimensions, noopTracker));
+            return dataLines.filter((line) => line.trim().length > 0).filter((line) => ProducerManager_default.shouldReadLine(line, recordSelector)).flatMap((line) => LineParser_default.parseAll(line, producer, dimensions, noopTracker)).map((record) => ProducerManager_default.applyFills(record, fills, sourceFilename));
           }
           if (discover) {
             return rawData.map((item) => ({ ...item }));
@@ -44343,9 +44395,15 @@ var init_ProducerEngine = __esm({
               const key = dim.alias ?? dim.name;
               record[dim.name] = TypeCaster_default.cast(item[key], dim.type, dim.format);
             }
-            return record;
+            return ProducerManager_default.applyFills(record, fills, sourceFilename);
           });
         };
+        /**
+         * The producer's declared dimensions in the shape `compileFills` reads them in. Declaration
+         * order, because a fill is addressed by key and never by position — unlike the executor
+         * dimensions of a run, whose index is reconciled against the file's own header.
+         */
+        this._fillDimensions = (producer) => producer.dimensions.map((prodDimension, index) => ({ index, name: prodDimension.name, prodDimension }));
         /**
          * Builds the executor dimensions of a producer. There are two shapes of source: a FIXED file has
          * no header, so its layout comes from the positions declared on the dimensions; every other file
@@ -46813,9 +46871,10 @@ var init_MockDataFactory = __esm({
           if (type === "number") {
             const first = bounds?.min ?? 1;
             const last = first + poolSize - 1;
+            const ceiling = bounds?.max;
             Affirm_default(
-              bounds?.max === void 0 || bounds.max >= last,
-              `Key "${norm}" has a synth range of ${first}-${bounds.max}, which holds fewer than the ${poolSize} distinct values it has to generate; widen it or generate fewer records`
+              ceiling === void 0 || ceiling >= last,
+              `Key "${norm}" has a synth range of ${first}-${ceiling}, which holds fewer than the ${poolSize} distinct values it has to generate; widen it or generate fewer records`
             );
             for (let i6 = 0; i6 < poolSize; i6++) pool.push(first + i6);
             return pool;
@@ -48155,23 +48214,23 @@ var init_Diagnostics = __esm({
           return [.../* @__PURE__ */ new Set([...inputs, ...chained])];
         };
         this._walk = (start, next, onCycle) => {
-          const path20 = [];
+          const path21 = [];
           const onPath = /* @__PURE__ */ new Set();
           const stack = [{ name: start, done: false }];
           const visited = /* @__PURE__ */ new Set();
           while (stack.length > 0) {
             const frame = stack.pop();
             if (frame.done) {
-              onPath.delete(path20.pop());
+              onPath.delete(path21.pop());
               continue;
             }
             if (onPath.has(frame.name)) {
-              path20.slice(path20.indexOf(frame.name)).forEach((name) => onCycle.add(name));
+              path21.slice(path21.indexOf(frame.name)).forEach((name) => onCycle.add(name));
               continue;
             }
             if (visited.has(frame.name)) continue;
             visited.add(frame.name);
-            path20.push(frame.name);
+            path21.push(frame.name);
             onPath.add(frame.name);
             stack.push({ name: frame.name, done: true });
             const successors = next.get(frame.name) ?? [];
@@ -48848,8 +48907,8 @@ var init_ResourceView = __esm({
           if (!source || origin.path.length < 2) return { value: "declared here", muted: true };
           return { value: `${source.resource}.${source.field}`, link: source.node };
         };
-        this._pathText = (path20) => {
-          return path20.map((step) => `${step.resource}.${step.field}`).join(" \u2192 ");
+        this._pathText = (path21) => {
+          return path21.map((step) => `${step.resource}.${step.field}`).join(" \u2192 ");
         };
         this._consumerOutputsTable = (env2, consumer) => {
           const declared = new Set((env2.sources ?? []).map((x2) => x2.name));
@@ -49879,17 +49938,30 @@ var init_LocalUsageDB = __esm({
           }
         };
         /**
-         * The recorded runs, newest first. Only the tail of the file is decoded: a reader wants the recent
+         * The recorded runs, newest first — the newest `limit` of the rows `keep` accepts.
+         *
+         * Decoded from the end and stopped as soon as that many are held: a reader wants the recent
          * executions, and decoding ten thousand rows to show ten of them is work nobody asked for.
          *
+         * `keep` is applied BEFORE the limit, which is the only way "the newest N runs of this kind" can
+         * mean it: filtering afterwards lets the rows a caller does not want displace the ones it does,
+         * so one sample recorded here would silently push a real run out of a history someone is reading.
+         *
          * Never throws. A missing file reads as no history, and so does a half-written one — this store is
          * appended to while it is being read, so failing on that would make it unreadable during a run.
          */
-        this.list = (limit = MAX_LISTED_ROWS) => {
+        this.list = (limit = MAX_LISTED_ROWS, keep) => {
           try {
             if (!(0, import_fs12.existsSync)(CLI_DB_PATH))
               return [];
-            return this._getRows().slice(-Math.max(1, limit)).map((line) => this._fromLine(line)).reverse();
+            const rows = this._getRows();
+            const wanted = Math.max(1, limit);
+            const found = [];
+            for (let index = rows.length - 1; index >= 0 && found.length < wanted; index--) {
+              const usage = this._fromLine(rows[index]);
+              if (!keep || keep(usage)) found.push(usage);
+            }
+            return found;
           } catch (error) {
             this._handleError("list", error);
             return [];
@@ -50070,9 +50142,10 @@ var init_UsageManager = __esm({
 });
 
 // ../../packages/engines/src/ops/RunOverlay.ts
-var MAX_RUNS, MAX_OPERATIONS, RunOverlayClass, RunOverlay;
+var import_crypto4, MAX_RUNS, MAX_OPERATIONS, RunOverlayClass, RunOverlay;
 var init_RunOverlay = __esm({
   "../../packages/engines/src/ops/RunOverlay.ts"() {
+    import_crypto4 = __toESM(require("crypto"), 1);
     init_src();
     init_LineageEngine();
     init_LocalUsageDB();
@@ -50081,6 +50154,8 @@ var init_RunOverlay = __esm({
     MAX_OPERATIONS = 40;
     RunOverlayClass = class {
       constructor() {
+        /** The last store token read, and the overlay token it resolved to. */
+        this._signed = { store: null, overlay: "" };
         /**
          * The recent executions and their aggregates. ONE read of the store answers both, so a page
          * showing a graph, a run list and a timing breakdown costs one file read rather than three.
@@ -50091,20 +50166,40 @@ var init_RunOverlay = __esm({
         this.read = (limit = MAX_RUNS) => {
           Affirm_default(limit > 0, "Run overlay limit must be greater than zero");
           if (!UsageManager_default.recordsLocally()) return { runs: [], metrics: {} };
-          const stats = LocalUsageDB_default.list(limit).filter((stat) => stat?.consumer);
+          const stats = LocalUsageDB_default.list(limit, (stat) => !!stat?.consumer && stat.invokedBy !== "SAMPLE");
           return { runs: stats.map((stat) => this._run(stat)), metrics: this._metrics(stats) };
         };
         /**
-         * A token that changes when the run store does. Empty when there is nothing to read.
+         * A token that changes when the OVERLAY does. Empty when there is nothing to read.
          *
          * A run finishing changes no configuration file, so the config hash cannot notice it — this is
-         * the second half of what the preview polls, and it is cheap for the same reason the hash is
-         * affordable: it reads metadata, not records.
+         * the second half of what the preview polls.
+         *
+         * It signs the painted runs rather than the store, because the two do not move together: a
+         * sample is recorded like any other execution and then filtered out of `read`, so the store's
+         * own token changes while the picture does not. Signing the store there announced a project
+         * change for every sample — and a page told its resource changed drops the sample it is showing,
+         * which is exactly the rows someone had just asked for.
+         *
+         * Still cheap to poll: the store's mtime/size gates the read, so the rows are decoded only after
+         * something has actually been written, never once a second.
          */
         this.signature = () => {
           if (!UsageManager_default.recordsLocally()) return "";
-          return LocalUsageDB_default.signature();
+          const store = LocalUsageDB_default.signature();
+          if (store === this._signed.store) return this._signed.overlay;
+          const overlay = this._token(this.read());
+          this._signed = { store, overlay };
+          return overlay;
         };
+        /**
+         * A token over the whole overlay, runs and metrics alike.
+         *
+         * Everything it carries, not the newest row and a count: `endUsage` updates a row in place and a
+         * finish action writes runs of its own, so a narrower token would miss a transition the graph
+         * exists to show.
+         */
+        this._token = (overlay) => import_crypto4.default.createHash("sha256").update(JSON.stringify(overlay)).digest("hex");
         this._run = (stat) => {
           const startedAt = this._iso(stat.startedAt);
           return {
@@ -50350,63 +50445,6 @@ var init_PushdownEngine = __esm({
   }
 });
 
-// ../../packages/engines/src/producer/SampleEngine.ts
-var MAX_CHAIN_DEPTH2, SampleEngineClass, SampleEngine;
-var init_SampleEngine = __esm({
-  "../../packages/engines/src/producer/SampleEngine.ts"() {
-    init_src();
-    init_src4();
-    init_ProducerEngine();
-    MAX_CHAIN_DEPTH2 = 20;
-    SampleEngineClass = class {
-      constructor() {
-        /**
-         * @param resourceName a producer or consumer name, as declared.
-         * @throws when the name is neither, or when the source cannot be read.
-         */
-        this.read = async (resourceName, size = 10) => {
-          Affirm_default(resourceName, "Missing resource name to sample");
-          Affirm_default(size > 0, "Sample size must be greater than 0");
-          const producer = Environment_default.getProducer(resourceName);
-          if (producer)
-            return { kind: "producer", name: resourceName, records: await ProducerEngine_default.readSampleData(producer, size, false) };
-          const consumer = Environment_default.getConsumer(resourceName);
-          Affirm_default(consumer, `Resource "${resourceName}" not found. Please check if it exists as a producer or consumer.`);
-          return { kind: "consumer", name: resourceName, records: await this._readConsumer(consumer, size, []) };
-        };
-        /**
-         * A consumer has no data of its own until it runs, so what it shows is its FIRST input, projected
-         * through its field list — near enough to answer "what will come out of this" without a run.
-         */
-        this._readConsumer = async (consumer, size, visited) => {
-          Affirm_default(!visited.includes(consumer.name), `Consumer "${consumer.name}" reads itself through ${visited.join(" \u2192 ")}`);
-          Affirm_default(visited.length < MAX_CHAIN_DEPTH2, `Consumer chain from "${visited[0]}" is more than ${MAX_CHAIN_DEPTH2} deep`);
-          const input = consumer.producers[0];
-          Affirm_default(input, `Consumer "${consumer.name}" has no producers configured`);
-          const producer = Environment_default.getProducer(input.name);
-          if (!producer) {
-            const upstream = Environment_default.getConsumer(input.name);
-            Affirm_default(upstream, `Producer or consumer "${input.name}" not found for consumer "${consumer.name}"`);
-            return this._readConsumer(upstream, size, [...visited, consumer.name]);
-          }
-          const records = await ProducerEngine_default.readSampleData(producer, size, false);
-          if (consumer.fields.some((field) => field.key === "*")) return records;
-          return records.map((record) => this._project(consumer, record));
-        };
-        this._project = (consumer, record) => {
-          const projected = {};
-          for (const field of consumer.fields) {
-            if (field.key === "*") continue;
-            projected[field.alias || field.key] = record[field.key];
-          }
-          return projected;
-        };
-      }
-    };
-    SampleEngine = new SampleEngineClass();
-  }
-});
-
 // ../../packages/engines/src/transform/LookupRegistry.ts
 var LookupRegistryClass, LookupRegistry, LookupRegistry_default;
 var init_LookupRegistry = __esm({
@@ -50443,12 +50481,12 @@ var init_LookupRegistry = __esm({
 });
 
 // ../../packages/engines/src/transform/LookupKey.ts
-var import_crypto4, DELIMITER, idFor, LookupKey, LookupKey_default;
+var import_crypto5, DELIMITER, idFor, LookupKey, LookupKey_default;
 var init_LookupKey = __esm({
   "../../packages/engines/src/transform/LookupKey.ts"() {
-    import_crypto4 = __toESM(require("crypto"), 1);
+    import_crypto5 = __toESM(require("crypto"), 1);
     DELIMITER = String.fromCharCode(0);
-    idFor = (ref) => import_crypto4.default.createHash("sha1").update([ref.consumer, ref.key, ref.value].join(DELIMITER)).digest("hex").slice(0, 16);
+    idFor = (ref) => import_crypto5.default.createHash("sha1").update([ref.consumer, ref.key, ref.value].join(DELIMITER)).digest("hex").slice(0, 16);
     LookupKey = { idFor };
     LookupKey_default = LookupKey;
   }
@@ -51085,7 +51123,6 @@ var init_src10 = __esm({
     init_ProducerEngine();
     init_ProducerManager();
     init_PushdownEngine();
-    init_SampleEngine();
     init_TransformationEngine();
     init_TypeCaster();
     init_LookupRegistry();
@@ -51255,14 +51292,14 @@ var init_OutputExecutor = __esm({
 });
 
 // ../../packages/executors/src/ConsumerExecutor.ts
-var import_path18, import_fs13, import_readline6, import_promises13, import_crypto5, LIMIT_SCAN_BYTES, NEWLINE_BYTE, ConsumerExecutorClass, ConsumerExecutor, ConsumerExecutor_default;
+var import_path18, import_fs13, import_readline6, import_promises13, 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_crypto5 = __toESM(require("crypto"));
+    import_crypto6 = __toESM(require("crypto"));
     init_src10();
     init_src10();
     init_src10();
@@ -51501,7 +51538,7 @@ var init_ConsumerExecutor = __esm({
           let newLineCount = 0;
           const seen = /* @__PURE__ */ new Set();
           for await (const line of lineReader) {
-            const hash = import_crypto5.default.createHash("sha1").update(line).digest("base64");
+            const hash = import_crypto6.default.createHash("sha1").update(line).digest("base64");
             if (!seen.has(hash)) {
               seen.add(hash);
               if (!writer.write(line + "\n"))
@@ -51777,8 +51814,6 @@ var init_ProducerExecutor = __esm({
     init_src8();
     init_src4();
     init_src10();
-    init_src();
-    init_src10();
     init_src10();
     import_path19 = __toESM(require("path"));
     init_src2();
@@ -51809,20 +51844,14 @@ var init_ProducerExecutor = __esm({
          * the source file name or a mask, and what that file name is. None of it depends on the line, so
          * it is compiled once per chunk instead of rebuilt per line — including the mask's own
          * validation, which used to run once per dimension per line.
+         *
+         * The fills themselves come from `ProducerManager`, which is also where the sample path gets
+         * them: one producer stage, reached from two places.
          */
         this.compileLine = (dimensions, chunk) => {
           Affirm_default(dimensions, "Invalid producer dimensions");
           Affirm_default(chunk, "Invalid chunk");
-          const fills = [];
-          for (const dimension of dimensions) {
-            const { prodDimension } = dimension;
-            const mask = ProducerManager_default.getMask(prodDimension);
-            const sourceFilename = prodDimension.sourceFilename === true;
-            if (!sourceFilename && !Algo_default.hasVal(mask))
-              continue;
-            fills.push({ key: dimension.name, mask, sourceFilename, type: prodDimension.type });
-          }
-          return { fills, sourceFilename: import_path19.default.basename(chunk.fileUri) };
+          return { fills: ProducerManager_default.compileFills(dimensions), sourceFilename: import_path19.default.basename(chunk.fileUri) };
         };
         /**
          * The record(s) one source line produces. Almost always exactly one — a producer with a group
@@ -51843,14 +51872,8 @@ var init_ProducerExecutor = __esm({
           if (plan.fills.length === 0)
             return records;
           counter = performance.now();
-          for (const record of records) {
-            for (const fill2 of plan.fills) {
-              if (fill2.sourceFilename)
-                record[fill2.key] = plan.sourceFilename;
-              if (Algo_default.hasVal(fill2.mask))
-                record[fill2.key] = CryptoEngine_default.hashValue(fill2.mask, record[fill2.key]?.toString(), fill2.type);
-            }
-          }
+          for (const record of records)
+            ProducerManager_default.applyFills(record, plan.fills, plan.sourceFilename);
           tracker.measure("process-line:dimensions-filename-mask", performance.now() - counter);
           return records;
         };
@@ -52618,7 +52641,8 @@ var init_ExecutorOrchestrator = __esm({
           } catch (error) {
             Logger_default.log(`[${usageId}] Consumer "${consumer.name}" failed: ${Helper_default.asError(error).message} | ${OrchestratorHelper_default.formatMemoryUsage()}`);
             Logger_default.error(error);
-            await ConsumerOnFinishManager_default.onConsumerError(consumer, usageId, this.makeOnFinishRunner(consumer, request, usageId));
+            if (!request.skipExport)
+              await ConsumerOnFinishManager_default.onConsumerError(consumer, usageId, this.makeOnFinishRunner(consumer, request, usageId));
             Logger_default.log(`[${usageId}] Running cleanup after failure`);
             await this.performCleanupOperations(scope, tracker);
             UsageManager_default.failUsage(usageId, Helper_default.asError(error).message);
@@ -53571,6 +53595,163 @@ init_src4();
 init_OutputExecutor();
 init_ProducerExecutor();
 
+// ../../packages/executors/src/SampleRunner.ts
+var import_fs18 = __toESM(require("fs"));
+var import_promises18 = __toESM(require("fs/promises"));
+var import_path24 = __toESM(require("path"));
+var import_readline11 = __toESM(require("readline"));
+init_src();
+init_src3();
+init_src4();
+init_src8();
+init_src10();
+init_src7();
+init_src2();
+init_ExecutorOrchestrator();
+var MAX_WALK_DEPTH = 20;
+var SAMPLE_USER = { user: { _id: "sample", name: "sample", type: "licence" } };
+var SampleRunnerClass = class {
+  constructor() {
+    /**
+     * @param resourceName a producer or consumer name, as declared.
+     * @param rows the most rows to return, capped at `MAX_SAMPLE_ROWS`.
+     * @throws when the name is neither, when a source cannot be read, or when the pipeline itself
+     *         fails — a consumer whose transformation throws is a sample that reports the reason.
+     */
+    this.read = async (resourceName, rows = 10, details) => {
+      Affirm_default(resourceName, "Missing resource name to sample");
+      Affirm_default(rows > 0, "Sample size must be greater than 0");
+      const size = Math.min(rows, Constants_default.defaults.MAX_SAMPLE_ROWS);
+      const producer = Environment_default.getProducer(resourceName);
+      if (producer) {
+        const records = await ProducerEngine_default.readSampleData(producer, size, false);
+        return {
+          kind: "producer",
+          name: resourceName,
+          records,
+          note: `${records.length} row(s) read from the source now, with this producer's dimensions, types and masks applied.`
+        };
+      }
+      const consumer = Environment_default.getConsumer(resourceName);
+      Affirm_default(consumer, `Resource "${resourceName}" not found. Please check if it exists as a producer or consumer.`);
+      return this._runConsumer(consumer, size, details);
+    };
+    /**
+     * Runs the consumer for real and reads back what it produced.
+     *
+     * The output is captured instead of exported, so nothing reaches the consumer's destination and
+     * no onSuccess action fires: looking at data must never be indistinguishable from publishing it.
+     */
+    this._runConsumer = async (consumer, size, details) => {
+      this._assertStageable(consumer);
+      const capturePath = import_path24.default.resolve(import_path24.default.join(ExecutorScope_default.getBasePath(), `sample_${consumer.name}_${Helper_default.uuid()}.jsonl`));
+      ExecutorScope_default.ensurePath(capturePath);
+      try {
+        const result = await ExecutorOrchestrator_default.launch({
+          consumer,
+          // `SAMPLE`, so the run it records is distinguishable from one the project did. The
+          // executor treats it like any other invocation; only `RunOverlay` reads the marker.
+          details: { ...details ?? SAMPLE_USER, invokedBy: "SAMPLE" },
+          // The rows asked for, bounded the way `remora run -l` bounds them — pushed to the
+          // source and stopped early per worker wherever nothing downstream can drop a record.
+          options: { limit: size },
+          // Nothing reaches the destination and no finish action fires; the merged dataset
+          // comes back through the same capture the lookup and consumer-input runs use.
+          skipExport: true,
+          captureMainDatasetTo: capturePath,
+          captureFormat: "JSONL"
+        });
+        const captured = await this._readCapture(capturePath, size);
+        const records = captured.map((record) => this._inFieldOrder(consumer, record));
+        Logger_default.log(`[sample] Consumer "${consumer.name}": ${records.length} row(s) from ${result.inputCount} input line(s)`);
+        return {
+          kind: "consumer",
+          name: consumer.name,
+          records,
+          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 });
+      }
+    };
+    /**
+     * Refuses, naming the source, when a run could not read one of this consumer's producers.
+     *
+     * `RedshiftDriver.ready` and `HttpApiSourceDriver.ready` are unimplemented, so the pipeline
+     * cannot reach those sources at all. Checked up front because the alternative is a run that
+     * spins up a worker pool and then surfaces "Not implemented yet" from three layers down, which
+     * names neither the producer nor the source that caused it.
+     */
+    this._assertStageable = (consumer) => {
+      for (const producer of this._inputProducers(consumer)) {
+        const source = Environment_default.getSource(producer.source);
+        Affirm_default(source, `Producer "${producer.name}" of consumer "${consumer.name}" has no source "${producer.source}"`);
+        if (!DriverFactory_default.canStage(source.engine))
+          throw new Error(`Cannot sample consumer "${consumer.name}": its producer "${producer.name}" reads source "${source.name}", and a "${source.engine}" source cannot be run through the pipeline yet. Sample the producer "${producer.name}" instead to see its rows.`);
+      }
+    };
+    /**
+     * Every producer a run of this consumer would stage — its own, plus those of the consumers it
+     * reads as input or consults as a code_lookup table, since each of those is executed too.
+     */
+    this._inputProducers = (consumer, visited = []) => {
+      Affirm_default(!visited.includes(consumer.name), `Consumer "${consumer.name}" reads itself through ${visited.join(" \u2192 ")}`);
+      Affirm_default(visited.length < MAX_WALK_DEPTH, `Consumer chain from "${visited[0]}" is more than ${MAX_WALK_DEPTH} deep`);
+      const seen = [...visited, consumer.name];
+      const upstream = [
+        ...consumer.producers.map((entry) => entry.name),
+        ...ConsumerManager_default.collectLookupRefs(ConsumerManager_default.getExpandedFields(consumer)).map((ref) => ref.consumer)
+      ];
+      return upstream.flatMap((name) => {
+        const producer = Environment_default.getProducer(name);
+        if (producer) return [producer];
+        const nested = Environment_default.getConsumer(name);
+        Affirm_default(nested, `Producer or consumer "${name}" not found for consumer "${consumer.name}"`);
+        return this._inputProducers(nested, seen);
+      });
+    };
+    /**
+     * One row's keys in the order the consumer DECLARES its fields.
+     *
+     * A record comes out of a worker keyed in the order the producer's dimensions were read, which is
+     * the source's layout and not the consumer's — so a consumer declaring country, plan, is_active
+     * over a producer that stores is_active first would be shown its own columns in someone else's
+     * order. Invisible in an exported JSON object; the whole shape of the table here.
+     *
+     * Anything the record carries that the field list does not name is appended rather than dropped:
+     * a column that turns up unexpectedly is exactly the one worth seeing.
+     */
+    this._inFieldOrder = (consumer, record) => {
+      const declared = ConsumerManager_default.getExpandedFields(consumer).filter((field) => !field.cField.hidden).map((field) => field.finalKey);
+      const ordered = {};
+      for (const key of declared) {
+        if (key in record) ordered[key] = record[key];
+      }
+      for (const key of Object.keys(record)) {
+        if (!(key in ordered)) ordered[key] = record[key];
+      }
+      return ordered;
+    };
+    /** The captured dataset, which `captureFormat: 'JSONL'` guarantees is one JSON object per line. */
+    this._readCapture = async (capturePath, size) => {
+      if (!import_fs18.default.existsSync(capturePath)) return [];
+      const records = [];
+      const lines = import_readline11.default.createInterface({ input: import_fs18.default.createReadStream(capturePath), crlfDelay: Infinity });
+      try {
+        for await (const line of lines) {
+          if (!line.length) continue;
+          records.push(JSON.parse(line));
+          if (records.length >= size) break;
+        }
+      } finally {
+        lines.close();
+      }
+      return records;
+    };
+  }
+};
+var SampleRunner = new SampleRunnerClass();
+
 // src/workers/ExecutorWorker.ts
 registerExecutorWorker();
 /*! Bundled license information: