@forzalabs/remora 2.6.0 → 2.7.0

package/index.js

@@ -7852,15 +7852,15 @@ var require_index_cjs = __commonJS({
       };
     }
     function wrapConversion(toModel, graph2) {
-      const path30 = [graph2[toModel].parent, toModel];
+      const path32 = [graph2[toModel].parent, toModel];
       let fn = convert$1[graph2[toModel].parent][toModel];
       let cur = graph2[toModel].parent;
       while (graph2[cur].parent) {
-        path30.unshift(graph2[cur].parent);
+        path32.unshift(graph2[cur].parent);
         fn = link(convert$1[graph2[cur].parent][cur], fn);
         cur = graph2[cur].parent;
       }
-      fn.conversion = path30;
+      fn.conversion = path32;
       return fn;
     }
     function route(fromModel) {
@@ -8490,7 +8490,7 @@ var require_node2 = __commonJS({
 var require_tail_file = __commonJS({
   "../../node_modules/winston/lib/winston/tail-file.js"(exports2, module2) {
     "use strict";
-    var fs41 = require("fs");
+    var fs43 = require("fs");
     var { StringDecoder } = require("string_decoder");
     var { Stream } = require_readable();
     function noop() {
@@ -8511,7 +8511,7 @@ var require_tail_file = __commonJS({
         stream.emit("end");
         stream.emit("close");
       };
-      fs41.open(options2.file, "a+", "0644", (err2, fd) => {
+      fs43.open(options2.file, "a+", "0644", (err2, fd) => {
         if (err2) {
           if (!iter) {
             stream.emit("error", err2);
@@ -8523,10 +8523,10 @@ var require_tail_file = __commonJS({
         }
         (function read() {
           if (stream.destroyed) {
-            fs41.close(fd, noop);
+            fs43.close(fd, noop);
             return;
           }
-          return fs41.read(fd, buffer, 0, buffer.length, pos, (error, bytes) => {
+          return fs43.read(fd, buffer, 0, buffer.length, pos, (error, bytes) => {
             if (error) {
               if (!iter) {
                 stream.emit("error", error);
@@ -8585,8 +8585,8 @@ var require_tail_file = __commonJS({
 var require_file = __commonJS({
   "../../node_modules/winston/lib/winston/transports/file.js"(exports2, module2) {
     "use strict";
-    var fs41 = require("fs");
-    var path30 = require("path");
+    var fs43 = require("fs");
+    var path32 = require("path");
     var asyncSeries = require_series();
     var zlib3 = require("zlib");
     var { MESSAGE } = require_triple_beam();
@@ -8616,14 +8616,14 @@ var require_file = __commonJS({
         this._onError = this._onError.bind(this);
         if (options2.filename || options2.dirname) {
           throwIf("filename or dirname", "stream");
-          this._basename = this.filename = options2.filename ? path30.basename(options2.filename) : "winston.log";
-          this.dirname = options2.dirname || path30.dirname(options2.filename);
+          this._basename = this.filename = options2.filename ? path32.basename(options2.filename) : "winston.log";
+          this.dirname = options2.dirname || path32.dirname(options2.filename);
           this.options = options2.options || { flags: "a" };
         } else if (options2.stream) {
           console.warn("options.stream will be removed in winston@4. Use winston.transports.Stream");
           throwIf("stream", "filename", "maxsize");
           this._dest = this._stream.pipe(this._setupStream(options2.stream));
-          this.dirname = path30.dirname(this._dest.path);
+          this.dirname = path32.dirname(this._dest.path);
         } else {
           throw new Error("Cannot log to file without filename or stream.");
         }
@@ -8786,11 +8786,11 @@ var require_file = __commonJS({
           options2 = {};
         }
         options2 = normalizeQuery(options2);
-        const file = path30.join(this.dirname, this.filename);
+        const file = path32.join(this.dirname, this.filename);
         let buff = "";
         let results = [];
         let row = 0;
-        const stream = fs41.createReadStream(file, {
+        const stream = fs43.createReadStream(file, {
           encoding: "utf8"
         });
         stream.on("error", (err2) => {
@@ -8826,7 +8826,7 @@ var require_file = __commonJS({
         function add(buff2, attempt) {
           try {
             const log = JSON.parse(buff2);
-            if (check2(log)) {
+            if (check(log)) {
               push(log);
             }
           } catch (e7) {
@@ -8855,7 +8855,7 @@ var require_file = __commonJS({
           }
           results.push(log);
         }
-        function check2(log) {
+        function check(log) {
           if (!log) {
             return;
           }
@@ -8891,7 +8891,7 @@ var require_file = __commonJS({
        * TODO: Refactor me.
        */
       stream(options2 = {}) {
-        const file = path30.join(this.dirname, this.filename);
+        const file = path32.join(this.dirname, this.filename);
         const stream = new Stream();
         const tail = {
           file,
@@ -8941,8 +8941,8 @@ var require_file = __commonJS({
        */
       stat(callback) {
         const target = this._getFile();
-        const fullpath = path30.join(this.dirname, target);
-        fs41.stat(fullpath, (err2, stat) => {
+        const fullpath = path32.join(this.dirname, target);
+        fs43.stat(fullpath, (err2, stat) => {
           if (err2 && err2.code === "ENOENT") {
             debug("ENOENT\xA0ok", fullpath);
             this.filename = target;
@@ -9045,9 +9045,9 @@ var require_file = __commonJS({
        * @returns {WritableStream} Stream that writes to disk for the active file.
        */
       _createStream(source) {
-        const fullpath = path30.join(this.dirname, this.filename);
+        const fullpath = path32.join(this.dirname, this.filename);
         debug("create stream start", fullpath, this.options);
-        const dest = fs41.createWriteStream(fullpath, this.options).on("error", (err2) => debug(err2)).on("close", () => debug("close", dest.path, dest.bytesWritten)).on("open", () => {
+        const dest = fs43.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);
@@ -9070,16 +9070,16 @@ var require_file = __commonJS({
        */
       _incFile(callback) {
         debug("_incFile", this.filename);
-        const ext = path30.extname(this._basename);
-        const basename = path30.basename(this._basename, ext);
+        const ext = path32.extname(this._basename);
+        const basename = path32.basename(this._basename, ext);
         const tasks = [];
         if (this.zippedArchive) {
           tasks.push(
             function(cb) {
               const num = this._created > 0 && !this.tailable ? this._created : "";
               this._compressFile(
-                path30.join(this.dirname, `${basename}${num}${ext}`),
-                path30.join(this.dirname, `${basename}${num}${ext}.gz`),
+                path32.join(this.dirname, `${basename}${num}${ext}`),
+                path32.join(this.dirname, `${basename}${num}${ext}.gz`),
                 cb
               );
             }.bind(this)
@@ -9104,8 +9104,8 @@ var require_file = __commonJS({
        * @private
        */
       _getFile() {
-        const ext = path30.extname(this._basename);
-        const basename = path30.basename(this._basename, ext);
+        const ext = path32.extname(this._basename);
+        const basename = path32.basename(this._basename, ext);
         const isRotation = this.rotationFormat ? this.rotationFormat() : this._created;
         return !this.tailable && this._created ? `${basename}${isRotation}${ext}` : `${basename}${ext}`;
       }
@@ -9125,8 +9125,8 @@ var require_file = __commonJS({
         const isOldest = oldest !== 0 ? oldest : "";
         const isZipped = this.zippedArchive ? ".gz" : "";
         const filePath = `${basename}${isOldest}${ext}${isZipped}`;
-        const target = path30.join(this.dirname, filePath);
-        fs41.unlink(target, callback);
+        const target = path32.join(this.dirname, filePath);
+        fs43.unlink(target, callback);
       }
       /**
        * Roll files forward based on integer, up to maxFiles. e.g. if base if
@@ -9148,20 +9148,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 = path30.join(this.dirname, fileName);
-            fs41.exists(tmppath, (exists) => {
+            const tmppath = path32.join(this.dirname, fileName);
+            fs43.exists(tmppath, (exists) => {
               if (!exists) {
                 return cb(null);
               }
               fileName = `${basename}${i6}${ext}${isZipped}`;
-              fs41.rename(tmppath, path30.join(this.dirname, fileName), cb);
+              fs43.rename(tmppath, path32.join(this.dirname, fileName), cb);
             });
           }.bind(this, x2));
         }
         asyncSeries(tasks, () => {
-          fs41.rename(
-            path30.join(this.dirname, `${basename}${ext}${isZipped}`),
-            path30.join(this.dirname, `${basename}1${ext}${isZipped}`),
+          fs43.rename(
+            path32.join(this.dirname, `${basename}${ext}${isZipped}`),
+            path32.join(this.dirname, `${basename}1${ext}${isZipped}`),
             callback
           );
         });
@@ -9175,22 +9175,22 @@ var require_file = __commonJS({
        * @private
        */
       _compressFile(src, dest, callback) {
-        fs41.access(src, fs41.F_OK, (err2) => {
+        fs43.access(src, fs43.F_OK, (err2) => {
           if (err2) {
             return callback();
           }
           var gzip = zlib3.createGzip();
-          var inp = fs41.createReadStream(src);
-          var out = fs41.createWriteStream(dest);
+          var inp = fs43.createReadStream(src);
+          var out = fs43.createWriteStream(dest);
           out.on("finish", () => {
-            fs41.unlink(src, callback);
+            fs43.unlink(src, callback);
           });
           inp.pipe(gzip).pipe(out);
         });
       }
       _createLogDirIfNotExist(dirPath) {
-        if (!fs41.existsSync(dirPath)) {
-          fs41.mkdirSync(dirPath, { recursive: true });
+        if (!fs43.existsSync(dirPath)) {
+          fs43.mkdirSync(dirPath, { recursive: true });
         }
       }
     };
@@ -9274,9 +9274,9 @@ var require_http = __commonJS({
         };
         const auth = options2.params.auth || null;
         delete options2.params.auth;
-        const path30 = options2.params.path || null;
+        const path32 = options2.params.path || null;
         delete options2.params.path;
-        this._request(options2, auth, path30, (err2, res, body) => {
+        this._request(options2, auth, path32, (err2, res, body) => {
           if (res && res.statusCode !== 200) {
             err2 = new Error(`Invalid HTTP Status Code: ${res.statusCode}`);
           }
@@ -9304,12 +9304,12 @@ var require_http = __commonJS({
           method: "stream",
           params: options2
         };
-        const path30 = options2.params.path || null;
+        const path32 = options2.params.path || null;
         delete options2.params.path;
         const auth = options2.params.auth || null;
         delete options2.params.auth;
         let buff = "";
-        const req = this._request(options2, auth, path30);
+        const req = this._request(options2, auth, path32);
         stream.destroy = () => req.destroy();
         req.on("data", (data) => {
           data = (buff + data).split(/\n+/);
@@ -9335,14 +9335,14 @@ var require_http = __commonJS({
        * @param {string} path - request path
        * @param {function} callback - Continuation to respond to when complete.
        */
-      _request(options2, auth, path30, callback) {
+      _request(options2, auth, path32, callback) {
         options2 = options2 || {};
         auth = auth || this.auth;
-        path30 = path30 || this.path || "";
+        path32 = path32 || this.path || "";
         if (this.batch) {
-          this._doBatch(options2, callback, auth, path30);
+          this._doBatch(options2, callback, auth, path32);
         } else {
-          this._doRequest(options2, callback, auth, path30);
+          this._doRequest(options2, callback, auth, path32);
         }
       }
       /**
@@ -9352,18 +9352,18 @@ var require_http = __commonJS({
        * @param {Object?} auth - authentication options
        * @param {string} path - request path
        */
-      _doBatch(options2, callback, auth, path30) {
+      _doBatch(options2, callback, auth, path32) {
         this.batchOptions.push(options2);
         if (this.batchOptions.length === 1) {
           const me3 = this;
           this.batchCallback = callback;
           this.batchTimeoutID = setTimeout(function() {
             me3.batchTimeoutID = -1;
-            me3._doBatchRequest(me3.batchCallback, auth, path30);
+            me3._doBatchRequest(me3.batchCallback, auth, path32);
           }, this.batchInterval);
         }
         if (this.batchOptions.length === this.batchCount) {
-          this._doBatchRequest(this.batchCallback, auth, path30);
+          this._doBatchRequest(this.batchCallback, auth, path32);
         }
       }
       /**
@@ -9372,14 +9372,14 @@ var require_http = __commonJS({
        * @param {Object?} auth - authentication options
        * @param {string} path - request path
        */
-      _doBatchRequest(callback, auth, path30) {
+      _doBatchRequest(callback, auth, path32) {
         if (this.batchTimeoutID > 0) {
           clearTimeout(this.batchTimeoutID);
           this.batchTimeoutID = -1;
         }
         const batchOptionsCopy = this.batchOptions.slice();
         this.batchOptions = [];
-        this._doRequest(batchOptionsCopy, callback, auth, path30);
+        this._doRequest(batchOptionsCopy, callback, auth, path32);
       }
       /**
        * Make a request to a winstond server or any http server which can
@@ -9389,7 +9389,7 @@ var require_http = __commonJS({
        * @param {Object?} auth - authentication options
        * @param {string} path - request path
        */
-      _doRequest(options2, callback, auth, path30) {
+      _doRequest(options2, callback, auth, path32) {
         const headers = Object.assign({}, this.headers);
         if (auth && auth.bearer) {
           headers.Authorization = `Bearer ${auth.bearer}`;
@@ -9399,7 +9399,7 @@ var require_http = __commonJS({
           method: "POST",
           host: this.host,
           port: this.port,
-          path: `/${path30.replace(/^\//, "")}`,
+          path: `/${path32.replace(/^\//, "")}`,
           headers,
           auth: auth && auth.username && auth.password ? `${auth.username}:${auth.password}` : "",
           agent: this.agent
@@ -11761,7 +11761,7 @@ var CONSTANTS, Constants_default;
 var init_Constants = __esm({
   "../../packages/constants/src/Constants.ts"() {
     CONSTANTS = {
-      cliVersion: "2.6.0",
+      cliVersion: "2.7.0",
       backendVersion: 1,
       backendPort: 5088,
       workerVersion: 2,
@@ -11798,6 +11798,13 @@ var init_Constants = __esm({
       defaults: {
         REMORA_PATH: "./remora",
         PRODUCER_TEMP_FOLDER: ".temp",
+        /**
+         * Where `synth` writes its exports, inside the remora directory, when none is given with
+         * `-o`. A synthetic run never writes to the consumer's configured destination, so it needs
+         * a folder of its own — and one inside the project, so the files it leaves sit next to the
+         * configuration that produced them rather than somewhere in the user's tree.
+         */
+        SYNTH_OUTPUT_FOLDER: ".synth",
         SQL_MAX_QUERY_ROWS: 1e4,
         /**
          * Rows a SQL source hands over per round trip while STAGING a producer (a `FETCH` from a
@@ -11889,7 +11896,7 @@ var init_Constants = __esm({
         /**
          * Record layouts one FIXED output may write into a single file, which is also how many write
          * streams its block-ordering pass holds open. A copybook of this size is already unusual —
-         * the NASCO POD feed writes five transaction types — and the bound stops a generated config
+         * a POD-style transaction feed may write five transaction types — and the bound stops a generated config
          * from opening a descriptor per distinct value of the wrong field.
          */
         MAX_FIXED_LAYOUTS: 64,
@@ -12180,7 +12187,7 @@ var init_ProcessShutdownManager = __esm({
           const shutdownState = this._shutdownState;
           const shutdownDescription = `${shutdownState?.type ?? "intentional"} shutdown (${shutdownState?.reason ?? `exit:${code}`})`;
           if (scopeCount === 0) {
-            Logger_default.info(`Detected ${shutdownDescription} for ${this._runtimeName}. No executor scopes to clean up.`);
+            Logger_default.log(`Detected ${shutdownDescription} for ${this._runtimeName}. No executor scopes to clean up.`);
             return;
           }
           Logger_default.warn(`Detected ${shutdownDescription} for ${this._runtimeName}. Cleaning up ${scopeCount} executor scope${scopeCount === 1 ? "" : "s"}.`);
@@ -12694,7 +12701,7 @@ var init_ResourcesUtils = __esm({
 });
 
 // ../../packages/common/src/validation/Validator.ts
-var ValidatorClass, Validator, Validator_default;
+var MAX_SCALE, SIGN_MODES, USAGE_MODES, ValidatorClass, Validator, Validator_default;
 var init_Validator = __esm({
   "../../packages/common/src/validation/Validator.ts"() {
     init_src();
@@ -12704,6 +12711,13 @@ var init_Validator = __esm({
     init_ProcessENVManager();
     init_SecretManager();
     init_ResourcesUtils();
+    MAX_SCALE = 15;
+    SIGN_MODES = ["overpunch", "leading", "trailing"];
+    USAGE_MODES = {
+      "display": null,
+      "comp-3": "packed decimal (two digits per byte, the sign in the last nibble)",
+      "comp": "binary (a two's-complement integer of 2, 4 or 8 bytes)"
+    };
     ValidatorClass = class {
       constructor() {
         this.validateSources = (sources) => {
@@ -12805,6 +12819,9 @@ var init_Validator = __esm({
               errors.push(`Producer "${producer.name}" has dimension(s) ${typeless.join(", ")} with no "type". Only a repeating group (a dimension declaring nested "dimensions") may omit it.`);
             errors.push(...this.validateLegacySynthFields(producer));
             errors.push(...this.validateFixedWidthLayout(producer));
+            errors.push(...this.validateDimensionScale(producer));
+            errors.push(...this.validateDimensionSign(producer));
+            errors.push(...this.validateDimensionUsage(producer));
             errors.push(...this.validateDimensionMasks(producer));
             const sourceFilenameDimensions = producer.dimensions.filter((x2) => x2.sourceFilename === true);
             if (sourceFilenameDimensions.length > 1) {
@@ -12828,6 +12845,67 @@ var init_Validator = __esm({
           }
           return errors;
         };
+        /**
+         * Checks the implied decimals of a dimension. A wrong `scale` is the one layout error nothing
+         * downstream can catch — the value it produces is a perfectly plausible number, 10^n off — so
+         * every way of declaring one that cannot mean what it says is rejected here rather than read.
+         */
+        this.validateDimensionScale = (producer) => {
+          Affirm_default(producer, "Invalid producer");
+          const errors = [];
+          for (const dim of producer.dimensions ?? []) {
+            if (!Algo_default.hasVal(dim.scale)) continue;
+            const where = `Dimension "${dim.name}" of producer "${producer.name}"`;
+            if (dim.type !== "number")
+              errors.push(`${where} declares "scale" on a "${dim.type ?? "typeless"}" dimension: implied decimals only describe a "number".`);
+            if (!Number.isInteger(dim.scale) || dim.scale < 1)
+              errors.push(`${where} declares "scale" ${JSON.stringify(dim.scale)}: it counts implied decimal places, so it must be a whole number of 1 or more. A field written with its decimal point, or with no fraction at all, simply omits it.`);
+            else if (dim.scale > MAX_SCALE)
+              errors.push(`${where} declares "scale" ${dim.scale}, more than the ${MAX_SCALE} decimal places a number can carry without losing digits.`);
+          }
+          return errors;
+        };
+        /**
+         * Checks how a dimension says its sign is written. A mode Remora does not implement would leave
+         * the sign unread — a value of the right magnitude and the wrong direction, which is the one
+         * error a reconciliation finds and a run never does — so a typo fails `verify` rather than a run.
+         */
+        this.validateDimensionSign = (producer) => {
+          Affirm_default(producer, "Invalid producer");
+          const errors = [];
+          for (const dim of producer.dimensions ?? []) {
+            if (!Algo_default.hasVal(dim.sign)) continue;
+            const where = `Dimension "${dim.name}" of producer "${producer.name}"`;
+            if (dim.type !== "number")
+              errors.push(`${where} declares "sign" on a "${dim.type ?? "typeless"}" dimension: a written sign only describes a "number".`);
+            if (!SIGN_MODES.includes(dim.sign))
+              errors.push(`${where} declares "sign" ${JSON.stringify(dim.sign)}, which is not a way a sign can be written. Use ${SIGN_MODES.map((x2) => `"${x2}"`).join(", ")}, or omit it for a plain leading "-".`);
+          }
+          return errors;
+        };
+        /**
+         * Rejects a field the copybook says is stored as BYTES. `import-copybook` emits the `USAGE` it
+         * read rather than dropping it, because the field's digits are the ones a positional read would
+         * slice characters out of and get garbage from: the feed has to expand them to display before it
+         * is sent. Saying so here, naming the field and the conversion, is how the customer learns at
+         * compile instead of from a column of NaN after a run (docs/plans/mainframe.md open question 3).
+         */
+        this.validateDimensionUsage = (producer) => {
+          Affirm_default(producer, "Invalid producer");
+          const errors = [];
+          for (const dim of producer.dimensions ?? []) {
+            if (!Algo_default.hasVal(dim.usage)) continue;
+            const where = `Dimension "${dim.name}" of producer "${producer.name}"`;
+            if (!(dim.usage in USAGE_MODES)) {
+              errors.push(`${where} declares "usage" ${JSON.stringify(dim.usage)}, which is not a storage mode. Use ${Object.keys(USAGE_MODES).map((x2) => `"${x2}"`).join(", ")}.`);
+              continue;
+            }
+            const stored = USAGE_MODES[dim.usage];
+            if (stored)
+              errors.push(`${where} declares "usage": "${dim.usage}": the field is stored as ${stored}, not as characters, so a positional read cannot address it. Have the feed convert it to display before it is sent (the DFSORT/OUTREC step that converts the file also expands packed and binary fields), then remove "usage" from this dimension.`);
+          }
+          return errors;
+        };
         /**
          * Rejects a masking mode that is not one Remora implements. The producer schema can't: the value
          * may be a `{VAR}` reference that only resolves at runtime. Checked here so a typo fails `verify`
@@ -13384,7 +13462,7 @@ var init_Validator = __esm({
          */
         this.detectOnFinishRecursion = (consumer) => {
           const errors = [];
-          const path30 = [];
+          const path32 = [];
           const targetsOf = (cons) => {
             const names = [];
             for (const output of cons.outputs ?? []) {
@@ -13396,17 +13474,17 @@ var init_Validator = __esm({
             return names;
           };
           const walk = (name) => {
-            if (path30.some((x2) => x2.toLowerCase() === name.toLowerCase())) {
-              errors.push(`Consumer "${consumer.name}" has a cyclic run-consumer (onSuccess/onError) chain: ${[...path30, name].join(" -> ")}`);
+            if (path32.some((x2) => x2.toLowerCase() === name.toLowerCase())) {
+              errors.push(`Consumer "${consumer.name}" has a cyclic run-consumer (onSuccess/onError) chain: ${[...path32, name].join(" -> ")}`);
               return true;
             }
             const cons = Environment_default.getConsumer(name);
             if (!cons) return false;
-            path30.push(name);
+            path32.push(name);
             for (const target of targetsOf(cons)) {
               if (walk(target)) return true;
             }
-            path30.pop();
+            path32.pop();
             return false;
           };
           walk(consumer.name);
@@ -13463,7 +13541,7 @@ var init_Validator = __esm({
 });
 
 // ../../packages/common/src/ProducerExpander.ts
-var MAX_OCCURS, DEFAULT_GROUP_NAMING, DEFAULT_ROWS_NAMING, DEFAULT_OCCURRENCE_FIELD, DEFAULT_FLAG_NAMING, GROUP_NAMING_TOKENS, FLAG_NAMING_TOKENS, GROUP_FORBIDDEN_PROPERTIES, GROUP_ONLY_PROPERTIES, IDENTIFIER_PATTERN, ProducerExpanderClass, ProducerExpander, ProducerExpander_default;
+var MAX_OCCURS, DEFAULT_GROUP_NAMING, DEFAULT_ROWS_NAMING, DEFAULT_OCCURRENCE_FIELD, DEFAULT_FLAG_NAMING, GROUP_NAMING_TOKENS, FLAG_NAMING_TOKENS, INDEX_TOKEN_PATTERN, GROUP_FORBIDDEN_PROPERTIES, GROUP_ONLY_PROPERTIES, NESTED_FORBIDDEN_PROPERTIES, IDENTIFIER_PATTERN, ProducerExpanderClass, ProducerExpander, ProducerExpander_default;
 var init_ProducerExpander = __esm({
   "../../packages/common/src/ProducerExpander.ts"() {
     init_src();
@@ -13476,8 +13554,10 @@ var init_ProducerExpander = __esm({
     DEFAULT_FLAG_NAMING = "{field}{Flag}";
     GROUP_NAMING_TOKENS = ["{group}", "{index}", "{field}", "{Field}"];
     FLAG_NAMING_TOKENS = ["{field}", "{Field}", "{flag}", "{Flag}"];
-    GROUP_FORBIDDEN_PROPERTIES = ["type", "alias", "pk", "mask", "synth", "sourceFilename", "flags", "format"];
+    INDEX_TOKEN_PATTERN = /{index(\d*)}/g;
+    GROUP_FORBIDDEN_PROPERTIES = ["type", "alias", "pk", "mask", "synth", "sourceFilename", "flags", "format", "scale", "sign", "usage"];
     GROUP_ONLY_PROPERTIES = ["occurs", "indexFrom", "emit", "skipEmptyOccurrences", "occurrenceField"];
+    NESTED_FORBIDDEN_PROPERTIES = ["emit", "skipEmptyOccurrences", "occurrenceField"];
     IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
     ProducerExpanderClass = class {
       constructor() {
@@ -13556,22 +13636,25 @@ ${errors.map((x2) => `  - ${x2}`).join("\n")}`);
         this.isGroup = (dimension) => {
           return Array.isArray(dimension?.dimensions);
         };
-        this._validateGroup = (producer, declared, group3) => {
+        this._validateGroup = (producer, declared, group3, nesting = null) => {
           const errors = [];
-          const where = `group dimension "${group3.name}" of producer "${producer.name}"`;
+          const where = nesting ? `nested group dimension "${group3.name}" of ${nesting.where}` : `group dimension "${group3.name}" of producer "${producer.name}"`;
           if (!IDENTIFIER_PATTERN.test(group3.name ?? ""))
             errors.push(`The name of ${where} is used as a prefix for the names it generates, so it must be a valid identifier: letters, digits and underscores, not starting with a digit.`);
           const forbidden = GROUP_FORBIDDEN_PROPERTIES.filter((property) => group3[property] !== void 0);
           if (forbidden.length > 0)
             errors.push(`${where} declares ${forbidden.map((x2) => `"${x2}"`).join(", ")}: a group produces no column of its own, so ${forbidden.length > 1 ? "they" : "it"} would be silently ignored. Declare ${forbidden.length > 1 ? "them" : "it"} on the child dimension(s) instead.`);
-          errors.push(...Validator_default.validateFieldPosition(group3.position, `${where} (the extent of ONE occurrence)`));
+          errors.push(...Validator_default.validateFieldPosition(group3.position, `${where} (the extent of ONE occurrence${nesting ? ", RELATIVE to one occurrence of the group it sits in" : ""})`));
           const occurrenceWidth = this._isPositionValid(group3.position) ? this._width(group3.position) : null;
-          errors.push(...this._validateOccurs(declared, group3, occurrenceWidth, where));
+          errors.push(...this._validateNesting(group3, occurrenceWidth, nesting, where));
+          if (!nesting || typeof group3.occurs !== "object")
+            errors.push(...this._validateOccurs(declared, group3, occurrenceWidth, where));
           if (Algo_default.hasVal(group3.indexFrom) && group3.indexFrom !== 0 && group3.indexFrom !== 1)
             errors.push(`"indexFrom" on ${where} is ${JSON.stringify(group3.indexFrom)}: it must be 0 or 1.`);
-          errors.push(...this._validateEmit(group3, where));
+          if (!nesting)
+            errors.push(...this._validateEmit(group3, where));
           if (Algo_default.hasVal(group3.naming)) {
-            errors.push(...this._validateNaming(group3.naming, GROUP_NAMING_TOKENS, where));
+            errors.push(...this._validateNaming(group3.naming, this._groupNamingTokens(nesting?.depth ?? 0), where));
             const columns = this._occurrences(group3).max;
             if (columns > 1 && group3.emit !== "rows" && !group3.naming.includes("{index}"))
               errors.push(`"naming" on ${where} ("${group3.naming}") has no "{index}" token, so all ${columns} occurrences would generate the same dimension name.`);
@@ -13584,16 +13667,39 @@ ${errors.map((x2) => `  - ${x2}`).join("\n")}`);
           const childDupes = Algo_default.uniq(children.map((x2) => x2.name).filter((name, index, all) => all.indexOf(name) !== index));
           if (childDupes.length > 0)
             errors.push(`${where} declares duplicate child dimension name(s): ${childDupes.map((x2) => `"${x2}"`).join(", ")}.`);
-          for (const child of children)
-            errors.push(...this._validateGroupChild(child, occurrenceWidth, `child dimension "${child.name}" of ${where}`));
+          const inner = { depth: (nesting?.depth ?? 0) + 1, width: occurrenceWidth, where };
+          for (const child of children) {
+            errors.push(...this.isGroup(child) ? this._validateGroup(producer, declared, child, inner) : this._validateGroupChild(child, occurrenceWidth, `child dimension "${child.name}" of ${where}`));
+          }
           return errors;
         };
-        this._validateGroupChild = (child, occurrenceWidth, where) => {
+        /**
+         * What a group may only do at the top level. A nested group's occurrences are laid out inside one
+         * occurrence of its parent, which is itself placed by the line, so the inner count has to be
+         * statically known — a per-line count on both axes has no single place to be read from.
+         */
+        this._validateNesting = (group3, occurrenceWidth, nesting, where) => {
+          if (!nesting) return [];
           const errors = [];
-          if (this.isGroup(child)) {
-            errors.push(`${where} is itself a repeating group: nested groups are not supported yet. Declare the inner group as a sibling of the outer one, with its own absolute "position".`);
+          const forbidden = NESTED_FORBIDDEN_PROPERTIES.filter((property) => Algo_default.hasVal(group3[property]));
+          if (forbidden.length > 0)
+            errors.push(`${where} declares ${forbidden.map((x2) => `"${x2}"`).join(", ")}: ${forbidden.length > 1 ? "those properties describe" : "that property describes"} fanning a LINE out to one record per occurrence, which only the outermost group can do.`);
+          if (typeof group3.occurs === "object")
+            errors.push(`"occurs" on ${where} varies per line: a nested group repeats a fixed number of times inside one occurrence of the group it sits in, so its count cannot depend on the line. Declare a whole number, or lift the group out to the top level.`);
+          const { max } = this._occurrences(group3);
+          if (occurrenceWidth === null || !Number.isInteger(max) || max < 1 || !Algo_default.hasVal(nesting.width))
             return errors;
-          }
+          const start = group3.position.start ?? 1;
+          const end = start + max * occurrenceWidth - 1;
+          if (end > nesting.width)
+            errors.push(`${where} spans columns ${start}-${end} of an occurrence that is only ${nesting.width} character(s) wide. A nested group's position is RELATIVE to one occurrence of the group it sits in, and all ${max} of its own occurrences have to fit inside it.`);
+          return errors;
+        };
+        this._validateGroupChild = (child, occurrenceWidth, where) => {
+          const errors = [];
+          const groupOnly = GROUP_ONLY_PROPERTIES.filter((property) => Algo_default.hasVal(child[property]));
+          if (groupOnly.length > 0)
+            errors.push(`${where} declares ${groupOnly.map((x2) => `"${x2}"`).join(", ")} but has no "dimensions": ${groupOnly.length > 1 ? "those properties describe" : "that property describes"} a repeating group, and would be silently ignored here.`);
           if (child.sourceFilename === true)
             errors.push(`${where} declares "sourceFilename": that dimension isn't in the line at all, so repeating it inside a group is meaningless. Declare it outside the group.`);
           if (!child.type)
@@ -13706,9 +13812,9 @@ ${errors.map((x2) => `  - ${x2}`).join("\n")}`);
           const errors = [];
           const groupNames = declared.filter((x2) => this.isGroup(x2)).map((x2) => x2.name);
           for (const [index, dimension] of declared.entries()) {
-            for (const child of dimension.dimensions ?? []) {
+            for (const { child, parent } of this._descendants(dimension)) {
               if (!child.position?.after) continue;
-              errors.push(`"position.after" on child dimension "${child.name}" of group "${dimension.name}" (producer "${producer.name}"): a child's position is RELATIVE to one occurrence, so only the group itself can be anchored.`);
+              errors.push(`"position.after" on child dimension "${child.name}" of group "${parent.name}" (producer "${producer.name}"): a child's position is RELATIVE to one occurrence, so only the group itself can be anchored.`);
             }
             const after = dimension.position?.after;
             if (!after) continue;
@@ -13751,6 +13857,20 @@ ${errors.map((x2) => `  - ${x2}`).join("\n")}`);
             errors.push(`"flags" on ${where} lists ${flags.length} flag(s) but the dimension spans ${width} character(s): one flag decodes exactly one character.`);
           return errors;
         };
+        /** Every dimension declared inside this one, at any depth, with the group that declares it. */
+        this._descendants = (dimension) => {
+          const found = [];
+          for (const child of dimension.dimensions ?? [])
+            found.push({ child, parent: dimension }, ...this._descendants(child));
+          return found;
+        };
+        /**
+         * The naming tokens a group at this depth may use: its own `{index}`, plus one `{indexN}` per
+         * enclosing group, so a template can reach outward as far as the nesting goes and no further.
+         */
+        this._groupNamingTokens = (depth) => {
+          return [...GROUP_NAMING_TOKENS, ...Array.from({ length: depth }, (_3, level) => `{index${level + 1}}`)];
+        };
         this._validateNaming = (naming, allowed, where) => {
           const unknown = (naming.match(/{[^}]*}/g) ?? []).filter((token2) => !allowed.includes(token2));
           if (unknown.length === 0)
@@ -13859,16 +13979,12 @@ ${errors.map((x2) => `  - ${x2}`).join("\n")}`);
         this._expandGroup = (group3, layout) => {
           if (layout.isRows)
             return this._expandRowsGroup(group3);
-          const indexFrom = group3.indexFrom ?? 0;
-          const naming = group3.naming ?? DEFAULT_GROUP_NAMING;
-          const isPlanned = this._isPlanned(layout);
+          if (!this._isPlanned(layout))
+            return this._groupLeaves(group3, layout.start - 1, []);
           const leaves = [];
           for (let occurrence = 0; occurrence < layout.max; occurrence++) {
-            const base = isPlanned ? 0 : layout.start + occurrence * layout.width;
-            for (const child of group3.dimensions) {
-              const position = isPlanned ? { start: child.position.start, length: this._width(child.position), group: group3.name, occurrence } : { start: base + child.position.start - 1, length: this._width(child.position) };
-              leaves.push(this._groupLeaf(child, group3, this._applyGroupNaming(naming, group3.name, occurrence + indexFrom, child.name), position));
-            }
+            for (const leaf of this._occurrenceLeaves(group3, occurrence, []))
+              leaves.push({ ...leaf, position: { ...leaf.position, group: group3.name, occurrence } });
           }
           return leaves;
         };
@@ -13878,7 +13994,6 @@ ${errors.map((x2) => `  - ${x2}`).join("\n")}`);
          * no occurrence fixed — the read path picks it per record.
          */
         this._expandRowsGroup = (group3) => {
-          const naming = group3.naming ?? DEFAULT_ROWS_NAMING;
           const occurrenceField = {
             name: this._occurrenceFieldName(group3),
             description: `Which occurrence of "${group3.name}" this record carries`,
@@ -13886,14 +14001,41 @@ ${errors.map((x2) => `  - ${x2}`).join("\n")}`);
             occurrenceOf: group3.name,
             indexFrom: group3.indexFrom ?? 0
           };
-          const leaves = group3.dimensions.map((child) => this._groupLeaf(
-            child,
-            group3,
-            this._applyGroupNaming(naming, group3.name, 0, child.name),
-            { start: child.position.start, length: this._width(child.position), group: group3.name }
-          ));
+          const leaves = this._occurrenceLeaves(group3, 0, []).map((leaf) => ({ ...leaf, position: { ...leaf.position, group: group3.name } }));
           return [occurrenceField, ...leaves];
         };
+        /**
+         * Every leaf a group generates, with each `position.start` 1-based and RELATIVE to the region the
+         * group sits in: the line for a top-level group, one occurrence of the parent for a nested one.
+         * `base` is that region's 0-based offset, and `ancestors` the enclosing occurrence indices,
+         * nearest first, which the naming templates read as `{index1}`...`{indexN}`.
+         */
+        this._groupLeaves = (group3, base, ancestors) => {
+          const width = this._width(group3.position);
+          const leaves = [];
+          for (let occurrence = 0; occurrence < this._occurrences(group3).max; occurrence++) {
+            const offset = base + occurrence * width;
+            for (const leaf of this._occurrenceLeaves(group3, occurrence, ancestors))
+              leaves.push({ ...leaf, position: { ...leaf.position, start: leaf.position.start + offset } });
+          }
+          return leaves;
+        };
+        /**
+         * The leaves of ONE occurrence of a group, positioned relative to that occurrence's own start. A
+         * child that is itself a group contributes its own leaves instead, already flattened — so the
+         * outer template names what the inner one generated, and nesting costs the pipeline nothing.
+         */
+        this._occurrenceLeaves = (group3, occurrence, ancestors) => {
+          const naming = group3.naming ?? (group3.emit === "rows" ? DEFAULT_ROWS_NAMING : DEFAULT_GROUP_NAMING);
+          const indices = [occurrence + (group3.indexFrom ?? 0), ...ancestors];
+          const leaves = [];
+          for (const child of group3.dimensions) {
+            const inner = this.isGroup(child) ? this._groupLeaves(child, (child.position.start ?? 1) - 1, indices) : [{ ...child, position: { start: child.position.start ?? 1, length: this._width(child.position) } }];
+            for (const leaf of inner)
+              leaves.push(this._groupLeaf(leaf, group3, this._applyGroupNaming(naming, group3.name, indices, leaf.name), leaf.position));
+          }
+          return leaves;
+        };
         this._groupLeaf = (child, group3, name, position) => {
           const leaf = { ...child, name, position };
           if (!leaf.description && group3.description)
@@ -13928,8 +14070,9 @@ ${errors.map((x2) => `  - ${x2}`).join("\n")}`);
             rebased.after = position.after;
           return rebased;
         };
-        this._applyGroupNaming = (naming, group3, index, field) => {
-          return naming.replace(/{group}/g, group3).replace(/{index}/g, String(index)).replace(/{field}/g, field).replace(/{Field}/g, this._capitalize(field));
+        /** `indices[0]` is the group's own occurrence, `indices[n]` the one n levels out. */
+        this._applyGroupNaming = (naming, group3, indices, field) => {
+          return naming.replace(/{group}/g, group3).replace(INDEX_TOKEN_PATTERN, (token2, level) => String(indices[level === "" ? 0 : Number(level)] ?? token2)).replace(/{field}/g, field).replace(/{Field}/g, this._capitalize(field));
         };
         this._applyFlagNaming = (naming, field, flag) => {
           return naming.replace(/{field}/g, field).replace(/{Field}/g, this._capitalize(field)).replace(/{flag}/g, flag).replace(/{Flag}/g, this._capitalize(flag));
@@ -14957,8 +15100,8 @@ var init_HttpClient = __esm({
             throw new Error(err2.message ?? "An error occurred on GET.");
           }
         };
-        this.getWorkerUrl = (path30) => {
-          const cleanPath = path30.startsWith("/") ? path30.substring(1) : path30;
+        this.getWorkerUrl = (path32) => {
+          const cleanPath = path32.startsWith("/") ? path32.substring(1) : path32;
           return `${this.workerHost}/${cleanPath}`;
         };
         this.workerHost = ProcessENVManager_default.getEnvVariable("REMORA_WORKER_HOST") || "http://worker:5069";
@@ -15785,14 +15928,14 @@ var init_readFile = __esm({
     import_promises3 = require("fs/promises");
     filePromises = {};
     fileIntercept = {};
-    readFile2 = (path30, options2) => {
-      if (fileIntercept[path30] !== void 0) {
-        return fileIntercept[path30];
+    readFile2 = (path32, options2) => {
+      if (fileIntercept[path32] !== void 0) {
+        return fileIntercept[path32];
       }
-      if (!filePromises[path30] || options2?.ignoreCache) {
-        filePromises[path30] = (0, import_promises3.readFile)(path30, "utf8");
+      if (!filePromises[path32] || options2?.ignoreCache) {
+        filePromises[path32] = (0, import_promises3.readFile)(path32, "utf8");
       }
-      return filePromises[path30];
+      return filePromises[path32];
     };
   }
 });
@@ -15904,8 +16047,8 @@ var init_externalDataInterceptor = __esm({
       getFileRecord() {
         return fileIntercept;
       },
-      interceptFile(path30, contents) {
-        fileIntercept[path30] = Promise.resolve(contents);
+      interceptFile(path32, contents) {
+        fileIntercept[path32] = Promise.resolve(contents);
       },
       getTokenRecord() {
         return tokenIntercept;
@@ -17815,8 +17958,8 @@ var init_checkRegion = __esm({
   "../../node_modules/@smithy/core/dist-es/submodules/config/config-resolver/regionConfig/checkRegion.js"() {
     init_transport();
     validRegions = /* @__PURE__ */ new Set();
-    checkRegion = (region, check2 = isValidHostLabel) => {
-      if (!validRegions.has(region) && !check2(region)) {
+    checkRegion = (region, check = isValidHostLabel) => {
+      if (!validRegions.has(region) && !check(region)) {
         if (region === "*") {
           console.warn(`@smithy/config-resolver WARN - Please use the caller region instead of "*". See "sigv4a" in https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md.`);
         } else {
@@ -18985,8 +19128,8 @@ var init_createConfigValueProvider = __esm({
               return endpoint.url.href;
             }
             if ("hostname" in endpoint) {
-              const { protocol, hostname, port, path: path30 } = endpoint;
-              return `${protocol}//${hostname}${port ? ":" + port : ""}${path30}`;
+              const { protocol, hostname, port, path: path32 } = endpoint;
+              return `${protocol}//${hostname}${port ? ":" + port : ""}${path32}`;
             }
           }
           return endpoint;
@@ -19361,18 +19504,18 @@ var getAttrPathList;
 var init_getAttrPathList = __esm({
   "../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/getAttrPathList.js"() {
     init_types2();
-    getAttrPathList = (path30) => {
-      const parts = path30.split(".");
+    getAttrPathList = (path32) => {
+      const parts = path32.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: '${path30}' does not end with ']'`);
+            throw new EndpointError(`Path: '${path32}' 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: '${path30}'`);
+            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path32}'`);
           }
           if (squareBracketIndex !== 0) {
             pathList.push(part.slice(0, squareBracketIndex));
@@ -19393,9 +19536,9 @@ var init_getAttr = __esm({
   "../../node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/getAttr.js"() {
     init_types2();
     init_getAttrPathList();
-    getAttr = (value, path30) => getAttrPathList(path30).reduce((acc, index) => {
+    getAttr = (value, path32) => getAttrPathList(path32).reduce((acc, index) => {
       if (typeof acc !== "object") {
-        throw new EndpointError(`Index '${index}' in '${path30}' not found in '${JSON.stringify(value)}'`);
+        throw new EndpointError(`Index '${index}' in '${path32}' not found in '${JSON.stringify(value)}'`);
       } else if (Array.isArray(acc)) {
         const i6 = parseInt(index);
         return acc[i6 < 0 ? acc.length + i6 : i6];
@@ -19456,8 +19599,8 @@ var init_parseURL = __esm({
             return value;
           }
           if (typeof value === "object" && "hostname" in value) {
-            const { hostname: hostname2, port, protocol: protocol2 = "", path: path30 = "", query = {} } = value;
-            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path30}`);
+            const { hostname: hostname2, port, protocol: protocol2 = "", path: path32 = "", query = {} } = value;
+            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path32}`);
             url.search = Object.entries(query).map(([k7, v3]) => `${k7}=${v3}`).join("&");
             return url;
           }
@@ -21801,11 +21944,11 @@ var init_HttpBindingProtocol = __esm({
           const opTraits = translateTraits(operationSchema.traits);
           if (opTraits.http) {
             request.method = opTraits.http[0];
-            const [path30, search] = opTraits.http[1].split("?");
+            const [path32, search] = opTraits.http[1].split("?");
             if (request.path == "/") {
-              request.path = path30;
+              request.path = path32;
             } else {
-              request.path += path30;
+              request.path += path32;
             }
             const traitSearchParams = new URLSearchParams(search ?? "");
             for (const [key, value] of traitSearchParams) {
@@ -25518,12 +25661,12 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             const password = request.password ?? "";
             auth = `${username}:${password}`;
           }
-          let path30 = request.path;
+          let path32 = request.path;
           if (queryString) {
-            path30 += `?${queryString}`;
+            path32 += `?${queryString}`;
           }
           if (request.fragment) {
-            path30 += `#${request.fragment}`;
+            path32 += `#${request.fragment}`;
           }
           let hostname = request.hostname ?? "";
           if (hostname[0] === "[" && hostname.endsWith("]")) {
@@ -25535,7 +25678,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             headers: request.headers,
             host: hostname,
             method: request.method,
-            path: path30,
+            path: path32,
             port: request.port,
             agent,
             auth
@@ -26444,10 +26587,10 @@ ${longDate}
 ${credentialScope}
 ${toHex(hashedRequest)}`;
       }
-      getCanonicalPath({ path: path30 }) {
+      getCanonicalPath({ path: path32 }) {
         if (this.uriEscapePath) {
           const normalizedPathSegments = [];
-          for (const pathSegment of path30.split("/")) {
+          for (const pathSegment of path32.split("/")) {
             if (pathSegment?.length === 0)
               continue;
             if (pathSegment === ".")
@@ -26458,11 +26601,11 @@ ${toHex(hashedRequest)}`;
               normalizedPathSegments.push(pathSegment);
             }
           }
-          const normalizedPath = `${path30?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path30?.endsWith("/") ? "/" : ""}`;
+          const normalizedPath = `${path32?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path32?.endsWith("/") ? "/" : ""}`;
           const doubleEncoded = escapeUri(normalizedPath);
           return doubleEncoded.replace(/%2F/g, "/");
         }
-        return path30;
+        return path32;
       }
       validateResolvedCredentials(credentials) {
         if (typeof credentials !== "object" || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string") {
@@ -34228,12 +34371,107 @@ var init_FixedWidthParser = __esm({
   }
 });
 
+// ../../packages/parsing/src/NumericCodec.ts
+var SIGN_MODES2, OVERPUNCH_POSITIVE, OVERPUNCH_NEGATIVE, NumericCodecClass, NumericCodec, NumericCodec_default;
+var init_NumericCodec = __esm({
+  "../../packages/parsing/src/NumericCodec.ts"() {
+    SIGN_MODES2 = {
+      none: { pattern: /^([+-]?)(\d+(?:\.\d+)?)$/, shape: 'digits, with an optional leading "+" or "-"' },
+      leading: { pattern: /^([+-]?)(\d+(?:\.\d+)?)$/, shape: 'an optional leading "+" or "-", then digits' },
+      trailing: { pattern: /^(\d+(?:\.\d+)?)([+-]?)$/, shape: 'digits, then an optional "+" or "-"' },
+      overpunch: { pattern: /^(\d*)([0-9{}A-R])$/, shape: 'digits whose last byte carries the sign: "{" or "A"-"I" positive, "}" or "J"-"R" negative' }
+    };
+    OVERPUNCH_POSITIVE = "{ABCDEFGHI";
+    OVERPUNCH_NEGATIVE = "}JKLMNOPQR";
+    NumericCodecClass = class {
+      constructor() {
+        /**
+         * Reads a number out of such a field. `"0012345"` at `scale: 2` is `123.45`; `"123J"` under
+         * `sign: "overpunch"` is `-1231`. Both misreadings are silent — `12345` is as plausible an
+         * amount as `123.45`, and `NaN` is what a run gets today — so the decoding is declared by the
+         * layout and anything else is rejected.
+         *
+         * A value that is ALREADY a number has been decoded by whoever produced it (a JSON source, the
+         * synthetic input, a re-read staged value) and passes through untouched: both properties
+         * describe how the number is spelled in text, not the number.
+         */
+        this.parse = (value, field) => {
+          if (typeof value === "number") return value;
+          const text = String(value).trim();
+          const { digits, negative } = this.readSign(text, field.sign);
+          if (!field.scale) return Number(negative ? `-${digits}` : digits);
+          if (digits.includes("."))
+            throw new Error(`Cannot read "${text}" as a number with ${field.scale} implied decimal(s): the last ${field.scale} digits are the fraction, so the value cannot also carry a decimal point.`);
+          const padded = digits.padStart(field.scale + 1, "0");
+          const split2 = padded.length - field.scale;
+          return Number(`${negative ? "-" : ""}${padded.slice(0, split2)}.${padded.slice(split2)}`);
+        };
+        /**
+         * Writes a number the way the field spells it — the mirror of `parse`, so a value read from such
+         * a field can always be written back to one. `123.45` at `scale: 2` is `"12345"`, and `-1231`
+         * under `sign: "overpunch"` is `"123J"`. The result is unpadded, since the width is the field's
+         * to fill.
+         *
+         * Scaled through `toFixed`, which rounds in decimal: `(123.45).toFixed(2)` is `"123.45"` where
+         * `123.45 * 100` is `12344.999999999998`.
+         */
+        this.format = (value, field) => {
+          const parsed = typeof value === "number" ? value : Number(value);
+          if (!Number.isFinite(parsed))
+            throw new Error(`Cannot write "${value}" as a number: it is not a number.`);
+          const magnitude = Math.abs(parsed);
+          const digits = field.scale ? magnitude.toFixed(field.scale).replace(".", "") : String(magnitude);
+          return this.writeSign(digits, parsed < 0, field.sign);
+        };
+        /** Splits the written sign off a field, leaving the digits and whether the value is negative. */
+        this.readSign = (text, sign2) => {
+          const mode = SIGN_MODES2[sign2 ?? "none"];
+          const match = mode.pattern.exec(text);
+          if (!match)
+            throw new Error(`Cannot read "${text}" as a number: this field holds ${mode.shape}.`);
+          if (sign2 === "overpunch") return this.readOverpunch(match[1], match[2]);
+          const [digits, mark] = sign2 === "trailing" ? [match[1], match[2]] : [match[2], match[1]];
+          return { digits, negative: mark === "-" };
+        };
+        /** The last byte of an overpunched field, read back as its digit and its sign. */
+        this.readOverpunch = (leading, last) => {
+          const negative = OVERPUNCH_NEGATIVE.includes(last);
+          const digit = negative ? OVERPUNCH_NEGATIVE.indexOf(last) : OVERPUNCH_POSITIVE.indexOf(last);
+          return { digits: leading + (digit < 0 ? last : digit), negative };
+        };
+        /**
+         * Puts the sign back the way the field carries it. A positive overpunched value is written in its
+         * letter form (`123A`), which is what a signed DISPLAY field holds — the plain-digit form is the
+         * unsigned one, and a field declaring `sign` is signed.
+         */
+        this.writeSign = (digits, negative, sign2) => {
+          switch (sign2) {
+            case "overpunch": {
+              const zone = negative ? OVERPUNCH_NEGATIVE : OVERPUNCH_POSITIVE;
+              return digits.slice(0, -1) + zone[Number(digits.slice(-1))];
+            }
+            case "leading":
+              return `${negative ? "-" : "+"}${digits}`;
+            case "trailing":
+              return `${digits}${negative ? "-" : "+"}`;
+            default:
+              return negative ? `-${digits}` : digits;
+          }
+        };
+      }
+    };
+    NumericCodec = new NumericCodecClass();
+    NumericCodec_default = NumericCodec;
+  }
+});
+
 // ../../packages/parsing/src/FixedWidthWriter.ts
-var BASE_FILL, TYPE_FILL, FixedWidthWriterClass, FixedWidthWriter, FixedWidthWriter_default;
+var BASE_FILL, TYPE_FILL, MAX_SCALE2, SIGN_MODES3, FixedWidthWriterClass, FixedWidthWriter, FixedWidthWriter_default;
 var init_FixedWidthWriter = __esm({
   "../../packages/parsing/src/FixedWidthWriter.ts"() {
     init_src();
     init_src3();
+    init_NumericCodec();
     BASE_FILL = { align: "left", pad: " ", nullFill: " ", overflow: "fail" };
     TYPE_FILL = {
       string: BASE_FILL,
@@ -34241,6 +34479,8 @@ var init_FixedWidthWriter = __esm({
       datetime: BASE_FILL,
       boolean: BASE_FILL
     };
+    MAX_SCALE2 = 15;
+    SIGN_MODES3 = ["overpunch", "leading", "trailing"];
     FixedWidthWriterClass = class {
       constructor() {
         /**
@@ -34421,6 +34661,24 @@ var init_FixedWidthWriter = __esm({
             errors.push(`"position.pad" of ${where} must be a single character, not "${fill2.pad}"`);
           if (fill2.nullFill.length !== 1)
             errors.push(`"position.nullFill" of ${where} must be a single character, not "${fill2.nullFill}"`);
+          errors.push(...this.spellingErrors(column2, position, where));
+          return errors;
+        };
+        /**
+         * How the field says its number is written, checked before a record ever reaches it. A wrong
+         * `scale` writes a plausible amount that is 10^n off and a `sign` the mode cannot write throws
+         * on the first record, so both are rejected at compile — on the column's own type, since neither
+         * describes anything a string, a date or a boolean is spelled with.
+         */
+        this.spellingErrors = (column2, position, where) => {
+          const errors = [];
+          const declared = [position.scale === void 0 || position.scale === null ? null : "scale", position.sign ? "sign" : null].filter(Boolean);
+          if (declared.length > 0 && column2.type !== "number")
+            errors.push(`${declared.map((x2) => `"position.${x2}"`).join(" and ")} of ${where} ${declared.length > 1 ? "describe" : "describes"} how a number is written, but the field is a "${column2.type ?? "typeless"}"`);
+          if (position.scale !== void 0 && position.scale !== null && (!Number.isInteger(position.scale) || position.scale < 1 || position.scale > MAX_SCALE2))
+            errors.push(`"position.scale" of ${where} counts implied decimal places, so it must be a whole number between 1 and ${MAX_SCALE2}, not ${JSON.stringify(position.scale)}. A field written with its decimal point simply omits it.`);
+          if (position.sign && !SIGN_MODES3.includes(position.sign))
+            errors.push(`"position.sign" of ${where} is ${JSON.stringify(position.sign)}, which is not a way a sign can be written. Use ${SIGN_MODES3.map((x2) => `"${x2}"`).join(", ")}, or omit it for a plain leading "-".`);
           return errors;
         };
         /**
@@ -34446,7 +34704,9 @@ var init_FixedWidthWriter = __esm({
             align: fill2.align,
             pad: fill2.pad,
             nullText: fill2.nullFill.repeat(position.width),
-            overflow: fill2.overflow
+            overflow: fill2.overflow,
+            scale: position.scale,
+            sign: position.sign
           };
         };
         /** The three fill sources folded into one, nearest declaration first. */
@@ -34487,11 +34747,33 @@ var init_FixedWidthWriter = __esm({
          * run; see `overflowed`.
          */
         this.writeField = (value, field) => {
-          if (value === null || value === void 0) return field.nullText;
-          const text = typeof value === "string" ? value : String(value);
-          if (text.length === 0) return field.nullText;
+          if (value === null || value === void 0 || value === "") return field.nullText;
+          const text = this.fieldText(value, field);
           if (text.length > field.width) return this.overflowed(text, field);
-          return field.align === "right" ? text.padStart(field.width, field.pad) : text.padEnd(field.width, field.pad);
+          return this.filled(text, field);
+        };
+        /**
+         * The value as the text of its field. A field declaring `scale` or `sign` is spelled the way the
+         * layout says a number is spelled — `123.45` at `scale: 2` written back as `12345`, `-1231`
+         * under `sign: "overpunch"` as `123J` — and everything else is the value as it stands.
+         *
+         * Without this a read-and-write-back is silently wrong in both directions: a field read as
+         * `0012345` would be written `123.45`, which is the right number spelled the wrong way, in the
+         * one place nothing downstream re-reads.
+         */
+        this.fieldText = (value, field) => {
+          if (field.scale || field.sign) return NumericCodec_default.format(value, field);
+          return typeof value === "string" ? value : String(value);
+        };
+        /**
+         * The text filled out to the field's width, on the side away from `align`. A `leading` sign keeps
+         * the first column to itself and the fill goes between it and the digits — `-0001234`, the way a
+         * SIGN LEADING SEPARATE field is written — rather than ahead of a sign nothing would then find.
+         */
+        this.filled = (text, field) => {
+          if (field.align !== "right") return text.padEnd(field.width, field.pad);
+          if (field.sign === "leading") return text.charAt(0) + text.slice(1).padStart(field.width - 1, field.pad);
+          return text.padStart(field.width, field.pad);
         };
         /**
          * A value longer than its field. It fails the run by default: a truncated account number is a
@@ -34500,14 +34782,17 @@ var init_FixedWidthWriter = __esm({
          *
          * Where the layout genuinely specifies a cut, the end that survives follows `align`, which is
          * what a COBOL MOVE does: a left-aligned value keeps its head, a right-aligned one keeps its
-         * low-order tail.
+         * low-order tail. A `leading` sign survives either way — a cut that drops it writes the
+         * magnitude with the direction reversed, which is worse than the cut itself.
          */
         this.overflowed = (text, field) => {
           Affirm_default(
             field.overflow === "truncate",
             `Value "${text}" is ${text.length} characters, longer than the ${field.width} of field "${field.name}" at columns ${field.start}-${field.end}. Widen the field, or set its "overflow" to "truncate" if the layout really specifies a cut.`
           );
-          return field.align === "right" ? text.slice(text.length - field.width) : text.slice(0, field.width);
+          if (field.align !== "right") return text.slice(0, field.width);
+          if (field.sign === "leading") return text.charAt(0) + text.slice(text.length - field.width + 1);
+          return text.slice(text.length - field.width);
         };
         /**
          * What a record carries after its last field, BEFORE the newline the destination writes. Every
@@ -34515,7 +34800,7 @@ var init_FixedWidthWriter = __esm({
          * `lf` output needs nothing here and a `crlf` one needs the `\r` that turns that newline into a
          * CRLF — which is exactly what a CRLF file looks like to anything that splits on `\n`.
          *
-         * A real positional feed picks one terminator and holds it: the NASCO POD files are CRLF on
+         * A real positional feed picks one terminator and holds it: some are CRLF on
          * every line including the last, and `lf` is the default everywhere else.
          */
         this.lineSuffix = (output) => {
@@ -34587,7 +34872,7 @@ var require_pend = __commonJS({
 // ../../node_modules/yauzl/fd-slicer.js
 var require_fd_slicer = __commonJS({
   "../../node_modules/yauzl/fd-slicer.js"(exports2) {
-    var fs41 = require("fs");
+    var fs43 = require("fs");
     var util = require("util");
     var stream = require("stream");
     var Readable10 = stream.Readable;
@@ -34607,7 +34892,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self2 = this;
       self2.pend.go(function(cb) {
-        fs41.read(self2.fd, buffer, offset, length, position, function(err2, bytesRead, buffer2) {
+        fs43.read(self2.fd, buffer, offset, length, position, function(err2, bytesRead, buffer2) {
           cb();
           callback(err2, bytesRead, buffer2);
         });
@@ -34624,7 +34909,7 @@ var require_fd_slicer = __commonJS({
       self2.refCount -= 1;
       if (self2.refCount < 0) throw new Error("invalid unref");
       if (self2.refCount > 0) return;
-      fs41.close(self2.fd, onCloseDone);
+      fs43.close(self2.fd, onCloseDone);
       function onCloseDone(err2) {
         if (err2) {
           self2.emit("error", err2);
@@ -34656,7 +34941,7 @@ var require_fd_slicer = __commonJS({
       }
       self2.context.pend.go(function(cb) {
         var buffer = Buffer.allocUnsafe(toRead);
-        fs41.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err2, bytesRead) {
+        fs43.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err2, bytesRead) {
           if (err2) {
             self2.destroy(err2);
           } else if (bytesRead === 0) {
@@ -35016,7 +35301,7 @@ var require_crc32 = __commonJS({
 // ../../node_modules/yauzl/index.js
 var require_yauzl = __commonJS({
   "../../node_modules/yauzl/index.js"(exports2) {
-    var fs41 = require("fs");
+    var fs43 = require("fs");
     var zlib3 = require("zlib");
     var fd_slicer = require_fd_slicer();
     var util = require("util");
@@ -35041,9 +35326,9 @@ var require_yauzl = __commonJS({
     exports2.Entry = Entry;
     exports2.LocalFileHeader = LocalFileHeader;
     exports2.RandomAccessReader = RandomAccessReader;
-    function openPromise(path30, options2) {
+    function openPromise(path32, options2) {
       return new Promise((resolve, reject) => {
-        open(path30, { ...options2, lazyEntries: true }, function(err2, zipfile) {
+        open(path32, { ...options2, lazyEntries: true }, function(err2, zipfile) {
           if (err2) return reject(err2);
           resolve(zipfile);
         });
@@ -35073,7 +35358,7 @@ var require_yauzl = __commonJS({
         });
       });
     }
-    function open(path30, options2, callback) {
+    function open(path32, options2, callback) {
       if (typeof options2 === "function") {
         callback = options2;
         options2 = null;
@@ -35085,10 +35370,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs41.open(path30, "r", function(err2, fd) {
+      fs43.open(path32, "r", function(err2, fd) {
         if (err2) return callback(err2);
         fromFd(fd, options2, function(err3, zipfile) {
-          if (err3) fs41.close(fd, defaultCallback);
+          if (err3) fs43.close(fd, defaultCallback);
           callback(err3, zipfile);
         });
       });
@@ -35105,7 +35390,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs41.fstat(fd, function(err2, stats) {
+      fs43.fstat(fd, function(err2, stats) {
         if (err2) return callback(err2);
         var reader = new fd_slicer.FdSlicer(fd);
         fromRandomAccessReader(reader, stats.size, options2, callback);
@@ -39187,6 +39472,7 @@ var init_src6 = __esm({
     init_DatasetCodec();
     init_FixedWidthParser();
     init_FixedWidthWriter();
+    init_NumericCodec();
     init_ParseCompression();
     init_ParseHelper();
     init_XLSParser();
@@ -46861,6 +47147,16 @@ var init_LocalDestinationDriver = __esm({
          * sibling of the destination on purpose: rename is only atomic within one filesystem.
          */
         this._stagingPath = (toFilePath) => `${toFilePath}.${(0, import_crypto4.randomUUID)()}.partial`;
+        /**
+         * Creates the folder an export is about to be written into.
+         *
+         * An `exportName` may carry a prefix — it is written for an S3 key, where `outbound/feed.csv`
+         * needs no folder to exist — so a local destination has to make one. `saveFile` always did;
+         * `move` did not, and failed with a bare ENOENT naming the staging file rather than the folder.
+         */
+        this._ensureDirectory = async (toFilePath) => {
+          await import_promises10.default.mkdir(import_path11.default.dirname(toFilePath), { recursive: true });
+        };
         /** Removes a staging file a failed export left behind; never masks the original error. */
         this._discardStaging = async (stagingPath) => {
           try {
@@ -46872,6 +47168,7 @@ var init_LocalDestinationDriver = __esm({
           const toFilePath = import_path11.default.join(this._path, toName);
           const stagingPath = this._stagingPath(toFilePath);
           try {
+            await this._ensureDirectory(toFilePath);
             if (header)
               await DriverHelper_default.copyWithHeader(fromPath, stagingPath, header);
             else
@@ -46889,6 +47186,7 @@ var init_LocalDestinationDriver = __esm({
           const toFilePath = import_path11.default.join(this._path, toName);
           const stagingPath = this._stagingPath(toFilePath);
           try {
+            await this._ensureDirectory(toFilePath);
             const reader = fs15.createReadStream(fromPath);
             const writer = new BatchWriter_default(fs15.createWriteStream(stagingPath));
             if (header)
@@ -47512,9 +47810,9 @@ var init_UrlMinter = __esm({
           return config;
         };
         /** Walks a dot path (`data.uploadUrl`) into the response, answering undefined rather than throwing. */
-        this._resolve = (payload, path30) => {
+        this._resolve = (payload, path32) => {
           let current = payload;
-          for (const segment of path30.split(".")) {
+          for (const segment of path32.split(".")) {
             if (current === null || typeof current !== "object")
               return void 0;
             current = current[segment];
@@ -48024,6 +48322,7 @@ var import_dayjs, import_customParseFormat, import_utc, DAY_OF_YEAR_TOKEN, FORMA
 var init_TypeCaster = __esm({
   "../../packages/engines/src/transform/TypeCaster.ts"() {
     init_src();
+    init_src6();
     import_dayjs = __toESM(require("dayjs"), 1);
     import_customParseFormat = __toESM(require("dayjs/plugin/customParseFormat"), 1);
     import_utc = __toESM(require("dayjs/plugin/utc"), 1);
@@ -48065,6 +48364,7 @@ var init_TypeCaster = __esm({
         this.castDimension = (value, dimension) => {
           if (dimension.type && this.isMissing(value, dimension.type))
             return dimension.nullable === false ? TYPE_DEFAULTS[dimension.type] : null;
+          if (dimension.scale || dimension.sign) return NumericCodec_default.parse(value, dimension);
           return this.cast(value, dimension.type, dimension.format);
         };
         /** null/undefined for any type, plus the empty string for every type but `string`. */
@@ -51473,7 +51773,10 @@ var init_SyntheticInputEngine = __esm({
             name,
             type: dim.type ?? "string",
             format: dim.format,
-            decimals: synth2.decimals,
+            // An implied-decimal field holds exactly `scale` decimals, so that is what a generated
+            // value gets unless `synth` asks for another: a 4-decimal value in a `scale: 2` column
+            // is one the layout cannot write back.
+            decimals: synth2.decimals ?? dim.scale,
             min,
             max,
             isPk: dim.pk === true,
@@ -51636,6 +51939,652 @@ var init_SyntheticInputEngine = __esm({
   }
 });
 
+// ../../packages/engines/src/copybook/CopybookParser.ts
+var MAX_RECORD_WIDTH, USAGES, UNSUPPORTED_USAGES, CLAUSE_KEYWORDS, PICTURE_CHARS, EDIT_CHARS, DIGIT_CHARS, COMMENT_INDICATORS, INDICATORS, CopybookParserClass, CopybookParser, CopybookParser_default;
+var init_CopybookParser = __esm({
+  "../../packages/engines/src/copybook/CopybookParser.ts"() {
+    init_src();
+    MAX_RECORD_WIDTH = 32767;
+    USAGES = {
+      "DISPLAY": "display",
+      "COMP": "comp",
+      "COMPUTATIONAL": "comp",
+      "COMP-4": "comp",
+      "COMPUTATIONAL-4": "comp",
+      "COMP-5": "comp",
+      "COMPUTATIONAL-5": "comp",
+      "BINARY": "comp",
+      "COMP-3": "comp-3",
+      "COMPUTATIONAL-3": "comp-3",
+      "PACKED-DECIMAL": "comp-3"
+    };
+    UNSUPPORTED_USAGES = {
+      "COMP-1": "single-precision hexadecimal floating point",
+      "COMPUTATIONAL-1": "single-precision hexadecimal floating point",
+      "COMP-2": "double-precision hexadecimal floating point",
+      "COMPUTATIONAL-2": "double-precision hexadecimal floating point",
+      "INDEX": "a subscript, which holds no data of the record",
+      "POINTER": "an address, which holds no data of the record",
+      "DISPLAY-1": "double-byte characters"
+    };
+    CLAUSE_KEYWORDS = /* @__PURE__ */ new Set([
+      "PIC",
+      "PICTURE",
+      "USAGE",
+      "REDEFINES",
+      "OCCURS",
+      "SIGN",
+      "VALUE",
+      "VALUES",
+      "JUST",
+      "JUSTIFIED",
+      "SYNC",
+      "SYNCHRONIZED",
+      "BLANK",
+      "ASCENDING",
+      "DESCENDING",
+      "INDEXED",
+      "EXTERNAL",
+      "GLOBAL",
+      ...Object.keys(USAGES),
+      ...Object.keys(UNSUPPORTED_USAGES)
+    ]);
+    PICTURE_CHARS = "XA9VSPZ*$,B0/.+-";
+    EDIT_CHARS = "Z*$,B0/";
+    DIGIT_CHARS = "9Z*";
+    COMMENT_INDICATORS = "*/";
+    INDICATORS = " */-";
+    CopybookParserClass = class {
+      constructor() {
+        /**
+         * Parses copybook text into one record layout. Throws on the first clause it cannot read, naming
+         * the line it is on.
+         */
+        this.parse = (text) => {
+          Affirm_default(typeof text === "string", "Missing required parameter text");
+          const statements = this._statements(this._lines(text));
+          if (statements.length === 0)
+            throw new Error("The copybook holds no data description entries.");
+          const entries = statements.map((statement) => this._entry(statement)).filter((entry) => entry);
+          const [record, ...alternates] = this._tree(entries);
+          if (!record)
+            throw new Error("The copybook declares no record: there is no 01 level item.");
+          for (const alternate of alternates) {
+            if (!alternate.redefines)
+              this._fail(alternate.line, `"${alternate.name}" is a second record description, and a producer reads one record layout. Split the copybook, and read each record type with its own producer and a "recordSelector".`);
+          }
+          const fields = record.fields ?? [record];
+          const width = this._place(fields);
+          const redefinedBy = alternates.map((x2) => x2.name);
+          return { name: record.name, line: record.line, width, fields, redefinedBy: redefinedBy.length > 0 ? redefinedBy : void 0 };
+        };
+        /** Throws about the copybook line a problem is on, which is the only way to locate it. */
+        this._fail = (line, message) => {
+          throw new Error(`Copybook line ${line}: ${message}`);
+        };
+        /**
+         * The lines that hold definitions, with their comments and their sequence and identification
+         * areas removed. Fixed-format and free-format copybooks are both read, decided per line: a line
+         * whose first six characters are a sequence number (or blank) and whose seventh is an indicator
+         * is read as columns 8-72, and any other line is read whole.
+         */
+        this._lines = (text) => {
+          const lines = [];
+          text.split(/\r?\n/).forEach((raw, index) => {
+            const fixed = /^(\d{6}| {6})$/.test(raw.slice(0, 6)) && INDICATORS.includes(raw.charAt(6));
+            if (fixed && COMMENT_INDICATORS.includes(raw.charAt(6))) return;
+            const content = fixed ? raw.slice(7, 72) : raw;
+            if (content.trim().length === 0 || content.trimStart().startsWith("*")) return;
+            lines.push({ text: content, line: index + 1 });
+          });
+          return lines;
+        };
+        /**
+         * The data description entries, split on the periods that terminate them. A period only
+         * terminates where it is followed by a space or the end of the line, so the one inside
+         * `PIC 9(5).99` stays part of the picture.
+         */
+        this._statements = (lines) => {
+          const statements = [];
+          let current = null;
+          for (const { text, line } of lines) {
+            for (const token2 of this._tokens(text, line)) {
+              if (!current) current = { tokens: [], line };
+              if (token2 !== ".") {
+                current.tokens.push(token2);
+                continue;
+              }
+              if (current.tokens.length > 0) statements.push(current);
+              current = null;
+            }
+          }
+          if (current)
+            this._fail(current.line, `the entry starting "${current.tokens.slice(0, 3).join(" ")}" is never terminated by a period.`);
+          return statements;
+        };
+        /** One line's tokens: quoted literals whole, a terminating period on its own, words otherwise. */
+        this._tokens = (content, line) => {
+          const tokens = [];
+          let index = 0;
+          while (index < content.length) {
+            const char = content.charAt(index);
+            if (/\s/.test(char)) {
+              index++;
+              continue;
+            }
+            if (char === '"' || char === "'") {
+              const close = content.indexOf(char, index + 1);
+              if (close < 0) this._fail(line, `a ${char === '"' ? "double" : "single"}-quoted literal is never closed.`);
+              tokens.push(content.slice(index, close + 1));
+              index = close + 1;
+              continue;
+            }
+            if (this._terminates(content, index)) {
+              tokens.push(".");
+              index++;
+              continue;
+            }
+            let end = index;
+            while (end < content.length && !/\s/.test(content.charAt(end)) && !this._terminates(content, end)) end++;
+            tokens.push(content.slice(index, end));
+            index = end;
+          }
+          return tokens;
+        };
+        /** Whether the character at `index` is a period that ends an entry rather than one inside it. */
+        this._terminates = (content, index) => {
+          if (content.charAt(index) !== ".") return false;
+          const next = content.charAt(index + 1);
+          return next === "" || /\s/.test(next);
+        };
+        /**
+         * One data description entry: its level, its name and its clauses. Returns `null` for a level 88
+         * condition name, which describes values of the item above it and occupies no storage.
+         */
+        this._entry = (statement) => {
+          const { tokens, line } = statement;
+          const level = Number(tokens[0]);
+          if (!Number.isInteger(level) || !/^\d{1,2}$/.test(tokens[0]))
+            this._fail(line, `"${tokens[0]}" is not a level number: an entry starts with one, written as 01-49, 66, 77 or 88.`);
+          if (level === 88) return null;
+          if (level === 66)
+            this._fail(line, `level 66 (RENAMES) regroups fields that are already described: read them under their own names instead.`);
+          if (level < 1 || level > 49 && level !== 77)
+            this._fail(line, `level ${tokens[0]} is not a level a data item can be declared at (01-49, 66, 77 or 88).`);
+          const named = tokens.length > 1 && !CLAUSE_KEYWORDS.has(tokens[1].toUpperCase());
+          const name = named ? tokens[1] : "FILLER";
+          const clauses = {};
+          let index = named ? 2 : 1;
+          while (index < tokens.length)
+            index = this._clause(clauses, tokens, index, statement);
+          return this._field(level, name, clauses, line);
+        };
+        /**
+         * Reads the clause starting at `index` into `clauses` and answers where the next one begins. The
+         * branches live in one place so that an unreadable clause is reported from one place too.
+         */
+        this._clause = (clauses, tokens, index, statement) => {
+          const keyword = tokens[index].toUpperCase();
+          const { line } = statement;
+          switch (keyword) {
+            case "PIC":
+            case "PICTURE":
+              return this._picture(clauses, tokens, this._skip(tokens, index + 1, "IS"), line);
+            case "USAGE":
+              return this._usage(clauses, tokens, this._skip(tokens, index + 1, "IS"), line);
+            case "REDEFINES":
+              return this._redefines(clauses, tokens, index + 1, line);
+            case "OCCURS":
+              return this._occurs(clauses, tokens, index + 1, line);
+            case "SIGN":
+              return this._sign(clauses, tokens, this._skip(tokens, index + 1, "IS"), line);
+            case "VALUE":
+            case "VALUES":
+            case "JUST":
+            case "JUSTIFIED":
+            case "SYNC":
+            case "SYNCHRONIZED":
+            case "BLANK":
+            case "ASCENDING":
+            case "DESCENDING":
+            case "INDEXED":
+            case "EXTERNAL":
+            case "GLOBAL":
+              return this._ignore(tokens, index + 1);
+            default:
+              if (USAGES[keyword] || UNSUPPORTED_USAGES[keyword]) return this._usage(clauses, tokens, index, line);
+              return this._fail(line, `"${tokens[index]}" is not a clause this reads, in the definition of "${tokens[1] ?? tokens[0]}".`);
+          }
+        };
+        /** Steps past an optional noise word (`IS`, `TO`, `BY`, `ON`), which changes no meaning. */
+        this._skip = (tokens, index, word2) => {
+          return tokens[index]?.toUpperCase() === word2 ? index + 1 : index;
+        };
+        /** Consumes a clause whose content changes no position: its operands, up to the next clause. */
+        this._ignore = (tokens, index) => {
+          let next = index;
+          while (next < tokens.length && !CLAUSE_KEYWORDS.has(tokens[next].toUpperCase())) next++;
+          return next;
+        };
+        this._picture = (clauses, tokens, index, line) => {
+          if (!tokens[index]) this._fail(line, "a PIC clause states no picture.");
+          if (clauses.picture) this._fail(line, "the entry declares two PIC clauses.");
+          clauses.picture = tokens[index];
+          return index + 1;
+        };
+        this._usage = (clauses, tokens, index, line) => {
+          const word2 = tokens[index]?.toUpperCase() ?? "";
+          if (UNSUPPORTED_USAGES[word2])
+            this._fail(line, `USAGE ${word2} is ${UNSUPPORTED_USAGES[word2]}, which Remora does not read.`);
+          if (!USAGES[word2])
+            this._fail(line, `"${tokens[index]}" is not a storage mode a USAGE clause can name.`);
+          clauses.usage = USAGES[word2];
+          return index + 1;
+        };
+        this._redefines = (clauses, tokens, index, line) => {
+          if (!tokens[index]) this._fail(line, "a REDEFINES clause names no item.");
+          clauses.redefines = tokens[index];
+          return index + 1;
+        };
+        /** `OCCURS n [TO m] [TIMES] [DEPENDING [ON] name]`, the fixed and the varying repeat counts. */
+        this._occurs = (clauses, tokens, index, line) => {
+          const count = Number(tokens[index]);
+          if (!Number.isInteger(count) || count < 1)
+            this._fail(line, `"${tokens[index]}" is not a number of occurrences: OCCURS takes a whole number of 1 or more.`);
+          let next = index + 1;
+          clauses.occurs = count;
+          if (tokens[next]?.toUpperCase() === "TO") {
+            const max = Number(tokens[next + 1]);
+            if (!Number.isInteger(max) || max < count)
+              this._fail(line, `"${tokens[next + 1]}" is not an upper bound of 'OCCURS ${count} TO': it must be a whole number of ${count} or more.`);
+            clauses.occursMin = count;
+            clauses.occurs = max;
+            next += 2;
+          }
+          next = this._skip(tokens, next, "TIMES");
+          if (tokens[next]?.toUpperCase() !== "DEPENDING") return next;
+          next = this._skip(tokens, next + 1, "ON");
+          if (!tokens[next]) this._fail(line, "an OCCURS DEPENDING ON clause names no counting field.");
+          clauses.dependingOn = tokens[next];
+          return next + 1;
+        };
+        /** `SIGN [IS] LEADING|TRAILING [SEPARATE [CHARACTER]]`, which says where a written sign sits. */
+        this._sign = (clauses, tokens, index, line) => {
+          const word2 = tokens[index]?.toUpperCase() ?? "";
+          if (word2 !== "LEADING" && word2 !== "TRAILING")
+            this._fail(line, `"${tokens[index]}" is not a sign position: a SIGN clause takes LEADING or TRAILING.`);
+          clauses.signPosition = word2 === "LEADING" ? "leading" : "trailing";
+          const next = this._skip(tokens, index + 1, "SEPARATE");
+          if (next === index + 1) return next;
+          clauses.signSeparate = true;
+          return this._skip(tokens, next, "CHARACTER");
+        };
+        /** The parsed entry, with the picture and the sign clause finally read against each other. */
+        this._field = (level, name, clauses, line) => {
+          const field = {
+            name,
+            level,
+            line,
+            offset: 0,
+            width: 0,
+            occurs: clauses.occurs ?? 1,
+            occursMin: clauses.occursMin,
+            dependingOn: clauses.dependingOn,
+            redefines: clauses.redefines,
+            filler: name.toUpperCase() === "FILLER",
+            picture: clauses.picture,
+            usage: clauses.usage ?? "display"
+          };
+          if (!clauses.picture) return field;
+          return { ...field, ...this._measure(clauses, line) };
+        };
+        /**
+         * What a picture says the field is: how wide it is in characters, what its value reads as, where
+         * its decimal point is implied and how its sign is written. Every one of those is silent when it
+         * is wrong — a mis-measured width shifts every field after it — so an unreadable picture fails.
+         */
+        this._measure = (clauses, line) => {
+          const chars2 = this._expand(clauses.picture, line);
+          const signed = chars2[0] === "S";
+          const body = signed ? chars2.slice(1) : chars2;
+          if (body.includes("S")) this._fail(line, `"${clauses.picture}": 'S' can only be a picture's first character.`);
+          if (body.includes("P")) this._fail(line, `"${clauses.picture}": 'P' scales a value by a power of ten with no digit to show for it, which no Remora dimension can state.`);
+          const point = body.indexOf("V");
+          if (point !== body.lastIndexOf("V")) this._fail(line, `"${clauses.picture}" states more than one implied decimal point.`);
+          if (point >= 0 && body.includes(".")) this._fail(line, `"${clauses.picture}" states both an implied ('V') and a real ('.') decimal point.`);
+          const width = body.filter((x2) => x2 !== "V").length + (signed && clauses.signSeparate ? 1 : 0);
+          if (body.some((x2) => x2 === "X" || x2 === "A")) {
+            if (signed || point >= 0)
+              this._fail(line, `"${clauses.picture}" mixes character positions with 'S' or 'V', which only describe a number.`);
+            return { width, type: "string" };
+          }
+          if (!body.some((x2) => DIGIT_CHARS.includes(x2)))
+            this._fail(line, `"${clauses.picture}" has no digit and no character position: there is nothing for the field to hold.`);
+          const scale = point < 0 ? 0 : body.slice(point).filter((x2) => DIGIT_CHARS.includes(x2)).length;
+          return { width, scale: scale > 0 ? scale : void 0, ...this._numeric(body, clauses, signed, line) };
+        };
+        /**
+         * How a numeric field's value is written. An EDITED picture holds insertion characters as well
+         * as digits (`ZZ,ZZ9.99`), so its field is text: reading it as a number would mean deciding what
+         * the insertions mean, and deciding is what this parser does not do.
+         */
+        this._numeric = (body, clauses, signed, line) => {
+          const edits = body.filter((x2) => EDIT_CHARS.includes(x2));
+          const signs = body.filter((x2) => x2 === "+" || x2 === "-");
+          const floating = signs.length > 1 || signs.length === 1 && body[0] !== signs[0] && body[body.length - 1] !== signs[0];
+          if (edits.length > 0 || floating)
+            return { type: "string", edited: `its picture "${clauses.picture}" is edited (${Algo_default.uniq([...edits, ...signs]).join(" ")}), so the field holds those characters as well as digits` };
+          if (signs.length === 1)
+            return { type: "number", sign: body[0] === signs[0] ? "leading" : "trailing" };
+          if (!signed)
+            return { type: "number" };
+          if (clauses.signSeparate)
+            return { type: "number", sign: clauses.signPosition ?? "trailing" };
+          if (clauses.signPosition === "leading")
+            this._fail(line, `"${clauses.picture}" with SIGN IS LEADING carries its sign in the zone of the FIRST byte, and Remora reads an overpunched sign from the last. Ask for SIGN IS LEADING SEPARATE, or for a trailing sign.`);
+          return { type: "number", sign: "overpunch" };
+        };
+        /** A picture with its repeat counts expanded: `S9(3)V99` becomes `S 9 9 9 V 9 9`. */
+        this._expand = (picture, line) => {
+          const text = picture.toUpperCase().replace(/CR|DB/g, "BB");
+          const chars2 = [];
+          let index = 0;
+          while (index < text.length) {
+            const char = text.charAt(index);
+            if (char !== "(") {
+              if (!PICTURE_CHARS.includes(char)) this._fail(line, `"${picture}" holds "${char}", which is not a picture character.`);
+              chars2.push(char);
+              index++;
+              continue;
+            }
+            const close = text.indexOf(")", index);
+            const count = Number(text.slice(index + 1, close));
+            if (close < 0 || !Number.isInteger(count) || count < 1)
+              this._fail(line, `"${picture}" has a repeat count that is not a whole number of 1 or more.`);
+            if (chars2.length === 0) this._fail(line, `"${picture}" opens with a repeat count, which repeats nothing.`);
+            if (chars2.length + count > MAX_RECORD_WIDTH) this._fail(line, `"${picture}" expands past the ${MAX_RECORD_WIDTH}-character maximum.`);
+            const repeated = chars2[chars2.length - 1];
+            for (let i6 = 1; i6 < count; i6++) chars2.push(repeated);
+            index = close + 1;
+          }
+          return chars2;
+        };
+        /**
+         * The entries nested by their level numbers: each one belongs to the last entry declared at a
+         * lower level. `01` and `77` always start a record of their own, whatever precedes them.
+         */
+        this._tree = (entries) => {
+          const roots = [];
+          const stack = [];
+          for (const entry of entries) {
+            if (entry.level === 1 || entry.level === 77) stack.length = 0;
+            while (stack.length > 0 && stack[stack.length - 1].level >= entry.level) stack.pop();
+            const parent = stack[stack.length - 1];
+            if (!parent) roots.push(entry);
+            else parent.fields = [...parent.fields ?? [], entry];
+            stack.push(entry);
+          }
+          return roots;
+        };
+        /**
+         * Places every item: an offset inside the item that contains it, and a width of one occurrence.
+         * This is the whole point of reading the copybook rather than a spreadsheet of columns — an
+         * offset nobody typed is an offset nobody mistyped. Answers the width of the items as a whole.
+         */
+        this._place = (fields) => {
+          let cursor = 1;
+          for (const field of fields) {
+            if (field.fields && field.picture)
+              this._fail(field.line, `"${field.name}" has both a PIC clause and items declared under it.`);
+            if (field.fields) field.width = this._place(field.fields);
+            if (!field.width)
+              this._fail(field.line, `"${field.name}" has no PIC clause and no items under it, so its width is unknown.`);
+            if (field.redefines) {
+              this._redefine(fields, field);
+              continue;
+            }
+            field.offset = cursor;
+            cursor += field.width * field.occurs;
+            if (cursor - 1 > MAX_RECORD_WIDTH)
+              this._fail(field.line, `the record passes the ${MAX_RECORD_WIDTH}-character maximum at "${field.name}".`);
+          }
+          return cursor - 1;
+        };
+        /** Lays a REDEFINES item over the item it redefines, which is where its bytes already are. */
+        this._redefine = (siblings, field) => {
+          const target = siblings.find((x2) => x2 !== field && x2.name === field.redefines);
+          if (!target)
+            this._fail(field.line, `"${field.name}" REDEFINES "${field.redefines}", which is not an item declared beside it.`);
+          if (field.width > target.width)
+            this._fail(field.line, `"${field.name}" is ${field.width} characters and REDEFINES "${target.name}", which is ${target.width}: a redefinition cannot be wider than what it redefines.`);
+          field.offset = target.offset;
+          target.redefinedBy = [...target.redefinedBy ?? [], field.name];
+        };
+      }
+    };
+    CopybookParser = new CopybookParserClass();
+    CopybookParser_default = CopybookParser;
+  }
+});
+
+// ../../packages/engines/src/copybook/CopybookEmitter.ts
+var DEFAULT_SOURCE, REPEATED_FIELD_NAMING, CopybookEmitterClass, CopybookEmitter, CopybookEmitter_default;
+var init_CopybookEmitter = __esm({
+  "../../packages/engines/src/copybook/CopybookEmitter.ts"() {
+    init_src();
+    init_src4();
+    DEFAULT_SOURCE = "s_default";
+    REPEATED_FIELD_NAMING = "{group}{index}";
+    CopybookEmitterClass = class {
+      constructor() {
+        /**
+         * Emits the producer that reads the record this layout describes, with the notes a reader has
+         * to act on. Throws rather than emitting a layout the config loader would reject: a layout that
+         * is 95% right reads plausible values out of the wrong columns.
+         */
+        this.toProducer = (layout, options2) => {
+          Affirm_default(layout, "Invalid copybook layout");
+          Affirm_default(layout.fields?.length > 0, "The copybook layout holds no fields");
+          Affirm_default(options2?.name, "Missing required parameter name");
+          const emitted = this._items(layout.fields, 0);
+          if (emitted.length === 0)
+            throw new Error(`Record "${layout.name}" has no field to read: every item in it is FILLER or a redefinition.`);
+          this._names(emitted);
+          this._counts(emitted);
+          this._anchor(emitted);
+          const producer = {
+            name: options2.name,
+            description: `Imported from a COBOL copybook: record ${layout.name}, ${layout.width} characters.`,
+            source: options2.source ?? DEFAULT_SOURCE,
+            dimensions: emitted.map((x2) => x2.dimension),
+            settings: { fileType: "FIXED", fileKey: options2.fileKey ?? `${options2.name}.txt` },
+            _version: 1
+          };
+          this._check(producer);
+          return { producer, notes: this._notes(layout) };
+        };
+        /**
+         * The dimensions a list of copybook items emits, in layout order. A group that does not repeat
+         * is TRANSPARENT: it structures the copybook but generates no column, so its items are emitted
+         * in its place with their offsets carried down into the coordinate space of its own parent.
+         */
+        this._items = (fields, base) => {
+          const emitted = [];
+          for (const field of fields) {
+            if (field.redefines || field.filler) continue;
+            if (field.fields && !this._repeats(field)) {
+              const inner = this._items(field.fields, base + field.offset - 1);
+              emitted.push(...inner.map((x2) => ({ ...x2, qualifier: x2.qualifier || this._name(field.name) })));
+              continue;
+            }
+            emitted.push(this._item(field, base + field.offset));
+          }
+          return emitted;
+        };
+        /** Whether an item generates one dimension per occurrence rather than a single dimension. */
+        this._repeats = (field) => {
+          return field.occurs > 1 || !!field.dependingOn;
+        };
+        /** One copybook item as one dimension: a leaf, a repeating leaf, or a group of its own. */
+        this._item = (field, start) => {
+          const position = { start, length: field.width };
+          const span = field.width * field.occurs;
+          if (!field.fields && !this._repeats(field))
+            return { dimension: this._leaf(field, position), field, qualifier: "", start, span };
+          const children = field.fields ? this._items(field.fields, 0) : [{ dimension: this._leaf(field, { start: 1, length: field.width }), field, qualifier: "", start: 1, span: field.width }];
+          this._names(children);
+          this._rejectNestedCounts(field);
+          const dimension = {
+            name: this._name(field.name),
+            description: this._describe(field),
+            position,
+            occurs: field.occurs,
+            // A copybook's occurrences are numbered from 1, and the names read against the copybook.
+            indexFrom: 1,
+            naming: field.fields ? void 0 : REPEATED_FIELD_NAMING,
+            dimensions: children.map((x2) => x2.dimension)
+          };
+          return { dimension, field, qualifier: "", start, span };
+        };
+        /** A dimension that produces a column: its type, and how its number is spelled, if it is one. */
+        this._leaf = (field, position) => {
+          return {
+            name: this._name(field.name),
+            description: this._describe(field),
+            type: field.type,
+            position,
+            scale: field.scale,
+            sign: field.sign,
+            usage: field.usage === "display" ? void 0 : field.usage
+          };
+        };
+        /** What the copybook says about an item, kept beside the dimension it became. */
+        this._describe = (field) => {
+          const clauses = [field.name];
+          if (field.picture) clauses.push(`PIC ${field.picture}`);
+          if (field.usage !== "display") clauses.push(`USAGE ${field.usage.toUpperCase()}`);
+          if (field.dependingOn) clauses.push(`OCCURS ${field.occursMin ?? 1} TO ${field.occurs} DEPENDING ON ${field.dependingOn}`);
+          else if (field.occurs > 1) clauses.push(`OCCURS ${field.occurs}`);
+          const notes = [clauses.join(" ")];
+          if (field.edited) notes.push(`read as text because ${field.edited}`);
+          if (field.redefinedBy?.length > 0) notes.push(`${field.redefinedBy.join(", ")} redefine the same bytes and are not read`);
+          return notes.join("; ");
+        };
+        /**
+         * A per-line occurrence count is read from the LINE, and a nested group's occurrences sit inside
+         * one occurrence of its parent — there is no second axis to count along, and nowhere to record
+         * the count (docs/plans/mainframe.md open question 5).
+         */
+        this._rejectNestedCounts = (group3) => {
+          for (const field of this._walk(group3.fields ?? [])) {
+            if (!field.dependingOn) continue;
+            throw new Error(`Copybook line ${field.line}: "${field.name}" has OCCURS DEPENDING ON inside "${group3.name}", which repeats as well. A varying count is scanned along the line, so only the outermost group can have one.`);
+          }
+        };
+        /**
+         * Gives every dimension of one list a name no sibling has. A copybook qualifies two items of the
+         * same name by the group they sit in, and a flattened layout has to do the same: the group's
+         * name goes in front, and a number only if that still collides.
+         */
+        this._names = (emitted) => {
+          const taken = /* @__PURE__ */ new Set();
+          for (const item of emitted) {
+            const base = item.dimension.name;
+            const qualified = item.qualifier ? `${item.qualifier}${this._capitalize(base)}` : "";
+            let name = [base, qualified].find((x2) => x2 && !taken.has(x2));
+            for (let suffix = 2; !name && suffix <= emitted.length + 2; suffix++)
+              if (!taken.has(`${base}${suffix}`)) name = `${base}${suffix}`;
+            Affirm_default(name, `Cannot name the dimension read from copybook item "${item.field.name}"`);
+            item.dimension.name = name;
+            taken.add(name);
+          }
+        };
+        /**
+         * Resolves each `OCCURS ... DEPENDING ON` against the dimension that holds the count. The count
+         * is read per line, so the field holding it has to be read before the occurrences it counts.
+         */
+        this._counts = (emitted) => {
+          for (const [index, item] of emitted.entries()) {
+            const counter = item.field.dependingOn;
+            if (!counter) continue;
+            const source = emitted.find((x2, at3) => at3 < index && !x2.field.fields && x2.field.name === counter);
+            if (!source)
+              throw new Error(`Copybook line ${item.field.line}: "${item.field.name}" has OCCURS DEPENDING ON "${counter}", which is not a field read before it. The count has to be a field of this record, declared ahead of the group and outside every other one.`);
+            item.dimension.occurs = {
+              max: item.field.occurs,
+              min: item.field.occursMin || void 0,
+              from: `$${source.dimension.name}`
+            };
+          }
+        };
+        /**
+         * Anchors everything that follows a group whose occurrence count varies. That group's span
+         * differs line by line, so an absolute position past it reads the wrong characters on every line
+         * but the longest — `position.after` measures from where the occurrences actually ended.
+         */
+        this._anchor = (emitted) => {
+          let anchor = null;
+          for (const item of emitted) {
+            if (anchor) {
+              const offset = item.start - anchor.end;
+              if (offset < 1)
+                throw new Error(`Copybook line ${item.field.line}: "${item.field.name}" starts inside the occurrences of "${anchor.group}", which it is laid out after.`);
+              item.dimension.position = { after: anchor.group, start: offset, length: item.field.width };
+            }
+            if (item.field.dependingOn) anchor = { group: item.dimension.name, end: item.start + item.span - 1 };
+          }
+        };
+        /**
+         * Everything the copybook states that the producer cannot carry out on its own. Written against
+         * the copybook's own names and lines, because that is the document the reader checks it against.
+         */
+        this._notes = (layout) => {
+          const notes = [];
+          for (const field of this._walk(layout.fields)) {
+            if (field.usage !== "display")
+              notes.push(`${field.name} (line ${field.line}) is USAGE ${field.usage.toUpperCase()}: its digits are stored as bytes, so "remora compile" rejects it until the feed converts the field to display. It is laid out as the ${field.width} characters its PIC clause states.`);
+            if (field.edited)
+              notes.push(`${field.name} (line ${field.line}) reads as text: ${field.edited}.`);
+            if (field.redefinedBy?.length > 0)
+              notes.push(`${field.name} (line ${field.line}) is read as declared; ${field.redefinedBy.join(", ")} redefine the same bytes and were not emitted.`);
+          }
+          if (layout.redefinedBy?.length > 0)
+            notes.push(`Record ${layout.name} is read as declared; ${layout.redefinedBy.join(", ")} redefine the whole record and were not emitted.`);
+          return notes;
+        };
+        /** Every item of a layout, at any depth, in declaration order. */
+        this._walk = (fields) => {
+          return fields.flatMap((field) => [field, ...this._walk(field.fields ?? [])]);
+        };
+        /**
+         * Refuses to emit a layout the config loader would reject or expand into colliding names. The
+         * importer exists so that nobody transcribes a layout by hand; emitting one that does not load
+         * would hand the transcription back.
+         */
+        this._check = (producer) => {
+          const errors = ProducerExpander_default.validate(producer);
+          if (errors.length > 0)
+            throw new Error(`The copybook describes a layout Remora cannot read:
+${errors.map((x2) => `  - ${x2}`).join("\n")}`);
+          ProducerExpander_default.expand(Algo_default.deepClone(producer));
+        };
+        /** A COBOL data name as a dimension name: `CLM-TOT-AMT` reads as `clmTotAmt`. */
+        this._name = (cobol) => {
+          const parts = cobol.toLowerCase().split(/[^a-z0-9]+/).filter((x2) => x2.length > 0);
+          Affirm_default(parts.length > 0, `Cannot read a dimension name from the copybook item "${cobol}"`);
+          const name = parts.map((part, index) => index === 0 ? part : this._capitalize(part)).join("");
+          return /^\d/.test(name) ? `f${name}` : name;
+        };
+        this._capitalize = (text) => {
+          return text.charAt(0).toUpperCase() + text.slice(1);
+        };
+      }
+    };
+    CopybookEmitter = new CopybookEmitterClass();
+    CopybookEmitter_default = CopybookEmitter;
+  }
+});
+
 // ../../packages/engines/src/consumer/ConsumerManager.ts
 var ConsumerManagerClass, ConsumerManager, ConsumerManager_default;
 var init_ConsumerManager = __esm({
@@ -51799,21 +52748,21 @@ var init_ConsumerOnFinishManager = __esm({
     init_src2();
     ConsumerOnFinishManagerClass = class {
       constructor() {
-        this.onConsumerSuccess = async (consumer, executionId, runConsumer2) => {
+        this.onConsumerSuccess = async (consumer, executionId, runConsumer2, options2) => {
           void executionId;
           for (const output of consumer.outputs) {
             if (output.onSuccess)
-              await this.performOnSuccessActions(consumer, output, runConsumer2);
+              await this.performOnSuccessActions(consumer, output, runConsumer2, options2);
           }
         };
-        this.onConsumerError = async (consumer, executionId, runConsumer2) => {
+        this.onConsumerError = async (consumer, executionId, runConsumer2, options2) => {
           void executionId;
           for (const output of consumer.outputs) {
             if (output.onError)
-              await this.performOnErrorActions(consumer, output, runConsumer2);
+              await this.performOnErrorActions(consumer, output, runConsumer2, options2);
           }
         };
-        this.performOnSuccessActions = async (consumer, output, runConsumer2) => {
+        this.performOnSuccessActions = async (consumer, output, runConsumer2, options2) => {
           Affirm_default(consumer, "Invalid consumer");
           Affirm_default(output, "Invalid output");
           if (!output.onSuccess || output.onSuccess.length === 0)
@@ -51821,6 +52770,8 @@ var init_ConsumerOnFinishManager = __esm({
           for (const onSuccess of output.onSuccess) {
             switch (onSuccess.action) {
               case "move-file": {
+                if (this._skipped(consumer, options2))
+                  break;
                 await this.moveSourceFiles(consumer, onSuccess.moveToDestination);
                 break;
               }
@@ -51833,6 +52784,12 @@ var init_ConsumerOnFinishManager = __esm({
             }
           }
         };
+        /** Whether this run declines a move-file action, logged so the skip is visible in the run's log. */
+        this._skipped = (consumer, options2) => {
+          if (!options2?.skipFileMoves) return false;
+          Logger_default.info(`Skipping the move-file action of consumer "${consumer.name}": this run did not read its real sources`);
+          return true;
+        };
         /**
          * Runs the downstream consumer(s) named by a run-consumer action, sequentially in declared order.
          * A downstream failure (unknown consumer or a failed run) is logged and swallowed so it does not
@@ -51951,7 +52908,7 @@ var init_ConsumerOnFinishManager = __esm({
           await destinationDriver.copyFromS3(sourceSource.authentication["bucket"], fileKey, fileKey);
           await sourceDriver.deleteFile(fileKey);
         };
-        this.performOnErrorActions = async (consumer, output, runConsumer2) => {
+        this.performOnErrorActions = async (consumer, output, runConsumer2, options2) => {
           Affirm_default(consumer, "Invalid consumer");
           Affirm_default(output, "Invalid output");
           if (!output.onError || output.onError.length === 0)
@@ -51959,6 +52916,8 @@ var init_ConsumerOnFinishManager = __esm({
           for (const onError of output.onError) {
             switch (onError.action) {
               case "move-file": {
+                if (this._skipped(consumer, options2))
+                  break;
                 await this.moveSourceFiles(consumer, onError.moveToDestination);
                 break;
               }
@@ -52235,33 +53194,33 @@ var init_RequestValidator = __esm({
         this.resolveMembers = (consumer) => {
           return new Set(ConsumerManager_default.getExpandedFields(consumer).map((x2) => x2.finalKey));
         };
-        this.checkFilters = (value, context, path30, depth) => {
+        this.checkFilters = (value, context, path32, depth) => {
           const { MAX_REQUEST_FILTERS, MAX_REQUEST_FILTER_DEPTH } = Constants_default.defaults;
           if (!Array.isArray(value))
-            throw new Error(`Invalid "${path30}": expected an array of filters, got ${this.describe(value)}`);
+            throw new Error(`Invalid "${path32}": expected an array of filters, got ${this.describe(value)}`);
           if (value.length > MAX_REQUEST_FILTERS)
-            throw new Error(`Invalid "${path30}": ${value.length} filters is above the maximum of ${MAX_REQUEST_FILTERS}`);
+            throw new Error(`Invalid "${path32}": ${value.length} filters is above the maximum of ${MAX_REQUEST_FILTERS}`);
           if (depth > MAX_REQUEST_FILTER_DEPTH)
-            throw new Error(`Invalid filter at ${path30}: filters may not nest more than ${MAX_REQUEST_FILTER_DEPTH} deep`);
-          return value.map((x2, index) => this.checkFilter(x2, context, `${path30}[${index}]`, depth));
+            throw new Error(`Invalid filter at ${path32}: filters may not nest more than ${MAX_REQUEST_FILTER_DEPTH} deep`);
+          return value.map((x2, index) => this.checkFilter(x2, context, `${path32}[${index}]`, depth));
         };
-        this.checkFilter = (value, context, path30, depth) => {
+        this.checkFilter = (value, context, path32, depth) => {
           if (!value || typeof value !== "object" || Array.isArray(value))
-            throw new Error(`Invalid filter at ${path30}: expected an object, got ${this.describe(value)}`);
+            throw new Error(`Invalid filter at ${path32}: expected an object, got ${this.describe(value)}`);
           const filter = value;
           const unknownKey = Object.keys(filter).find((key) => !FILTER_KEYS.includes(key));
           if (unknownKey)
-            throw new Error(`Invalid filter at ${path30}: unknown property "${unknownKey}". Supported: ${FILTER_KEYS.join(", ")}`);
-          const operator = this.checkOperator(filter.operator, path30);
+            throw new Error(`Invalid filter at ${path32}: unknown property "${unknownKey}". Supported: ${FILTER_KEYS.join(", ")}`);
+          const operator = this.checkOperator(filter.operator, path32);
           const checked = {
-            member: this.checkMember(filter.member, context, path30),
+            member: this.checkMember(filter.member, context, path32),
             operator,
-            values: this.checkValues(filter.values, operator, path30)
+            values: this.checkValues(filter.values, operator, path32)
           };
           if (Algo_default.hasVal(filter.and))
-            checked.and = this.checkFilters(filter.and, context, `${path30}.and`, depth + 1);
+            checked.and = this.checkFilters(filter.and, context, `${path32}.and`, depth + 1);
           if (Algo_default.hasVal(filter.or))
-            checked.or = this.checkFilters(filter.or, context, `${path30}.or`, depth + 1);
+            checked.or = this.checkFilters(filter.or, context, `${path32}.or`, depth + 1);
           return checked;
         };
         /**
@@ -52269,18 +53228,18 @@ var init_RequestValidator = __esm({
          * own field names by the time filters run, so any other name reads `undefined` and quietly keeps
          * every row (or drops every row, for a negated operator).
          */
-        this.checkMember = (value, context, path30) => {
+        this.checkMember = (value, context, path32) => {
           if (typeof value !== "string" || value.length === 0)
-            throw new Error(`Invalid filter at ${path30}: "member" must be a non-empty string, got ${this.describe(value)}`);
+            throw new Error(`Invalid filter at ${path32}: "member" must be a non-empty string, got ${this.describe(value)}`);
           if (!context.members.has(value))
-            throw new Error(`Invalid filter at ${path30}: consumer "${context.consumer.name}" has no field named "${value}"`);
+            throw new Error(`Invalid filter at ${path32}: consumer "${context.consumer.name}" has no field named "${value}"`);
           return value;
         };
-        this.checkOperator = (value, path30) => {
+        this.checkOperator = (value, path32) => {
           if (typeof value !== "string" || !VALUES_BY_OPERATOR.has(value))
-            throw new Error(`Invalid filter at ${path30}: unknown operator ${this.describe(value)}. Supported: ${this.supportedOperators()}`);
+            throw new Error(`Invalid filter at ${path32}: unknown operator ${this.describe(value)}. Supported: ${this.supportedOperators()}`);
           if (VALUES_BY_OPERATOR.get(value) === "unsupported")
-            throw new Error(`Invalid filter at ${path30}: operator "${value}" is not supported by a run`);
+            throw new Error(`Invalid filter at ${path32}: operator "${value}" is not supported by a run`);
           return value;
         };
         /**
@@ -52288,24 +53247,24 @@ var init_RequestValidator = __esm({
          * own type and the filter's is read back into it, so a number or a boolean here is a client bug
          * that reads as a type mismatch (matching nothing) rather than as the comparison it meant.
          */
-        this.checkValues = (value, operator, path30) => {
+        this.checkValues = (value, operator, path32) => {
           const values = Algo_default.hasVal(value) ? value : [];
           if (!Array.isArray(values))
-            throw new Error(`Invalid filter at ${path30}: "values" must be an array of strings, got ${this.describe(value)}`);
+            throw new Error(`Invalid filter at ${path32}: "values" must be an array of strings, got ${this.describe(value)}`);
           const wrongIndex = values.findIndex((x2) => typeof x2 !== "string");
           if (wrongIndex >= 0)
-            throw new Error(`Invalid filter at ${path30}: "values[${wrongIndex}]" must be a string, got ${this.describe(values[wrongIndex])}`);
-          return this.checkArity(values, operator, path30);
+            throw new Error(`Invalid filter at ${path32}: "values[${wrongIndex}]" must be a string, got ${this.describe(values[wrongIndex])}`);
+          return this.checkArity(values, operator, path32);
         };
-        this.checkArity = (values, operator, path30) => {
+        this.checkArity = (values, operator, path32) => {
           const expected = VALUES_BY_OPERATOR.get(operator);
           const reason = `operator "${operator}"`;
           if (expected === "none" && values.length > 0)
-            throw new Error(`Invalid filter at ${path30}: ${reason} reads no values, ${values.length} given`);
+            throw new Error(`Invalid filter at ${path32}: ${reason} reads no values, ${values.length} given`);
           if (expected === "many" && values.length === 0)
-            throw new Error(`Invalid filter at ${path30}: ${reason} needs at least one value, none given`);
+            throw new Error(`Invalid filter at ${path32}: ${reason} needs at least one value, none given`);
           if (typeof expected === "number" && values.length !== expected)
-            throw new Error(`Invalid filter at ${path30}: ${reason} needs exactly ${expected} ${expected === 1 ? "value" : "values"}, ${values.length} given`);
+            throw new Error(`Invalid filter at ${path32}: ${reason} needs exactly ${expected} ${expected === 1 ? "value" : "values"}, ${values.length} given`);
           return values;
         };
         /** Every operator a request may ask for, in the order they are declared. */
@@ -52646,23 +53605,23 @@ var init_Diagnostics = __esm({
           return [.../* @__PURE__ */ new Set([...inputs, ...chained])];
         };
         this._walk = (start, next, onCycle) => {
-          const path30 = [];
+          const path32 = [];
           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(path30.pop());
+              onPath.delete(path32.pop());
               continue;
             }
             if (onPath.has(frame.name)) {
-              path30.slice(path30.indexOf(frame.name)).forEach((name) => onCycle.add(name));
+              path32.slice(path32.indexOf(frame.name)).forEach((name) => onCycle.add(name));
               continue;
             }
             if (visited.has(frame.name)) continue;
             visited.add(frame.name);
-            path30.push(frame.name);
+            path32.push(frame.name);
             onPath.add(frame.name);
             stack.push({ name: frame.name, done: true });
             const successors = next.get(frame.name) ?? [];
@@ -53341,8 +54300,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 = (path30) => {
-          return path30.map((step) => `${step.resource}.${step.field}`).join(" \u2192 ");
+        this._pathText = (path32) => {
+          return path32.map((step) => `${step.resource}.${step.field}`).join(" \u2192 ");
         };
         this._consumerOutputsTable = (env2, consumer) => {
           const declared = new Set((env2.sources ?? []).map((x2) => x2.name));
@@ -54377,17 +55336,17 @@ var init_BugReportBundle = __esm({
           }
         };
         /** Write one file into the bundle, under the section that produced it. */
-        this.add = (name, path30, content) => {
-          Affirm_default(path30, "Missing required parameter path");
-          Affirm_default(content !== void 0 && content !== null, `No content for bundle entry ${path30}`);
+        this.add = (name, path32, content) => {
+          Affirm_default(path32, "Missing required parameter path");
+          Affirm_default(content !== void 0 && content !== null, `No content for bundle entry ${path32}`);
           const section = this._section(name);
           Affirm_default(
             this._zip.getEntries().length < MAX_ENTRIES,
-            `Bug report reached its ${MAX_ENTRIES} file limit while writing ${path30}`
+            `Bug report reached its ${MAX_ENTRIES} file limit while writing ${path32}`
           );
-          this._zip.addFile(path30, Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8"));
+          this._zip.addFile(path32, Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8"));
           section.included = true;
-          section.files.push(path30);
+          section.files.push(path32);
         };
         /** Record that a section contributed nothing, and why. Absence without a reason reads as a bug. */
         this.skip = (name, reason) => {
@@ -56430,6 +57389,8 @@ var init_src10 = __esm({
     init_DeveloperEngine();
     init_LLM();
     init_SyntheticInputEngine();
+    init_CopybookParser();
+    init_CopybookEmitter();
     init_ConsumerManager();
     init_ConsumerOnFinishManager();
     init_RequestExecutor();
@@ -56541,9 +57502,10 @@ var init_DatasetSchema = __esm({
           return dsSchema.columns.map((column2) => column2.name);
         };
         /**
-         * One column, typed from the dimension behind it. `type`, `format` and `nullable` are the only
-         * three properties a cast reads, so carrying those lets a reader cast a staged value back
-         * without going near the consumer config.
+         * One column, typed from the dimension behind it. `type`, `format` and `nullable` are what a cast
+         * reads off a staged value, so carrying those lets a reader cast it back without going near the
+         * consumer config. A dimension's `scale` and `sign` deliberately do NOT travel: they say how the
+         * SOURCE spelled the number, and what is staged here is the number itself.
          */
         this._column = (field) => {
           if (ConsumerManager_default.isLineCountField(field.cField))
@@ -56670,9 +57632,10 @@ var init_FixedBlockOrder = __esm({
 });
 
 // ../../packages/executors/src/OutputExecutor.ts
-var OutputExecutorClass, OutputExecutor, OutputExecutor_default;
+var import_fs21, OutputExecutorClass, OutputExecutor, OutputExecutor_default;
 var init_OutputExecutor = __esm({
   "../../packages/executors/src/OutputExecutor.ts"() {
+    import_fs21 = __toESM(require("fs"));
     init_src();
     init_src();
     init_src8();
@@ -56760,17 +57723,17 @@ var init_OutputExecutor = __esm({
          * One output per consumer (`maxItems: 1` in consumer-schema.json). This used to loop, but only
          * ever shipped the first entry, and could not have done more: `move` unlinks what it ships.
          */
-        this.exportResult = async (consumer, dsSchema, splitFiles) => {
+        this.exportResult = async (consumer, dsSchema, splitFiles, localPath) => {
           Affirm_default.hasItems(splitFiles, `Consumer "${consumer.name}" has no output file to export`);
           Affirm_default.hasItems(consumer.outputs, `Consumer "${consumer.name}" declares no output to export to`);
           Affirm_default(dsSchema, `Consumer "${consumer.name}" has no dataset schema to export against`);
           const output = consumer.outputs[0];
           const internalFormat = dsSchema.encoding;
-          const destination = Environment_default.getSource(output.exportDestination);
-          Affirm_default(destination, `The export destination "${output.exportDestination}" of consumer "${consumer.name}" is not a source of this project`);
+          const destination = this._resolveDestination(consumer, output, localPath);
           const driver = await DriverFactory_default.instantiateDestination(destination);
           const destinationName = this._composeFileName(consumer, output, this._getExtension(output));
-          Logger_default.info(`Exporting consumer "${consumer.name}" to "${output.exportDestination}" as ${output.format} (${destinationName}, ${splitFiles.length} file(s))`);
+          const target = localPath ?? output.exportDestination;
+          Logger_default.info(`Exporting consumer "${consumer.name}" to "${target}" as ${output.format} (${destinationName}, ${splitFiles.length} file(s))`);
           const header = this._composeHeader(output, dsSchema);
           const fixedLayouts = output.format === "FIXED" && output.layouts ? FixedWidthWriter_default.compileLayouts(dsSchema, this._fixedPositions(consumer), output, consumer.name) : null;
           const fixedLine = output.format === "FIXED" ? this._fixedLineWriter(consumer, dsSchema, output, fixedLayouts) : null;
@@ -56933,6 +57896,25 @@ var init_OutputExecutor = __esm({
               return "txt";
           }
         };
+        /**
+         * Where this export writes: the consumer's configured destination, or — in synth mode — a local
+         * folder standing in for it, as a `local` source built on the spot.
+         *
+         * The real destination is never even resolved for a synthetic run, which is what lets a consumer
+         * pointed at a production bucket be synthesized from a machine that holds no credentials for it.
+         *
+         * Named here, not left to the driver: an unresolvable destination used to surface as a TypeError
+         * three layers down, naming neither the consumer nor the destination.
+         */
+        this._resolveDestination = (consumer, output, localPath) => {
+          if (localPath) {
+            import_fs21.default.mkdirSync(localPath, { recursive: true });
+            return { name: localPath, engine: "local", authentication: { method: "none", path: localPath }, _version: 1 };
+          }
+          const destination = Environment_default.getSource(output.exportDestination);
+          Affirm_default(destination, `The export destination "${output.exportDestination}" of consumer "${consumer.name}" is not a source of this project`);
+          return destination;
+        };
         this._composeFileName = (consumer, output, extension, executionId) => {
           if (output.exportName && output.exportName.trim().length > 0) {
             const sanitized = output.exportName.replace(/\.[^.]+$/, "");
@@ -56950,11 +57932,11 @@ var init_OutputExecutor = __esm({
 });
 
 // ../../packages/executors/src/ConsumerExecutor.ts
-var import_path19, import_fs21, import_promises16, import_crypto10, LIMIT_SCAN_BYTES, NEWLINE_BYTE, ConsumerExecutorClass, ConsumerExecutor, ConsumerExecutor_default;
+var import_path19, import_fs22, import_promises16, import_crypto10, LIMIT_SCAN_BYTES, NEWLINE_BYTE, ConsumerExecutorClass, ConsumerExecutor, ConsumerExecutor_default;
 var init_ConsumerExecutor = __esm({
   "../../packages/executors/src/ConsumerExecutor.ts"() {
     import_path19 = __toESM(require("path"));
-    import_fs21 = __toESM(require("fs"));
+    import_fs22 = __toESM(require("fs"));
     import_promises16 = __toESM(require("fs/promises"));
     import_crypto10 = __toESM(require("crypto"));
     init_src10();
@@ -56971,10 +57953,10 @@ var init_ConsumerExecutor = __esm({
       constructor() {
         this._ensurePath = (pathUri) => {
           const dir = import_path19.default.dirname(pathUri);
-          if (!import_fs21.default.existsSync(dir))
-            import_fs21.default.mkdirSync(dir, { recursive: true });
-          if (!import_fs21.default.existsSync(pathUri))
-            import_fs21.default.writeFileSync(pathUri, "");
+          if (!import_fs22.default.existsSync(dir))
+            import_fs22.default.mkdirSync(dir, { recursive: true });
+          if (!import_fs22.default.existsSync(pathUri))
+            import_fs22.default.writeFileSync(pathUri, "");
         };
         /**
          * Shapes one parsed producer record into one consumer record, following a plan compiled once per
@@ -57102,8 +58084,8 @@ var init_ConsumerExecutor = __esm({
           const parseLine = LineParser_default.datasetParser(dsSchema);
           const outputPlan = OutputExecutor_default.compileOutput(consumer, dsSchema);
           const tempWorkPath = datasetPath + "_tmp";
-          const reader = import_fs21.default.createReadStream(datasetPath);
-          const writer = import_fs21.default.createWriteStream(tempWorkPath);
+          const reader = import_fs22.default.createReadStream(datasetPath);
+          const writer = import_fs22.default.createWriteStream(tempWorkPath);
           const waitForDrain = () => new Promise((resolve) => writer.once("drain", resolve));
           let workerIndex = 0;
           let currentWorker = executorResults[workerIndex] ?? null;
@@ -57194,9 +58176,9 @@ var init_ConsumerExecutor = __esm({
         };
         this.processDistinct = async (dsSchema, datasetPath) => {
           Affirm_default(dsSchema, "Invalid dataset schema");
-          const reader = import_fs21.default.createReadStream(datasetPath);
+          const reader = import_fs22.default.createReadStream(datasetPath);
           const tempWorkPath = datasetPath + "_tmp";
-          const writer = import_fs21.default.createWriteStream(tempWorkPath);
+          const writer = import_fs22.default.createWriteStream(tempWorkPath);
           const waitForDrain = () => new Promise((resolve) => writer.once("drain", resolve));
           let newLineCount = 0;
           const seen = /* @__PURE__ */ new Set();
@@ -57226,7 +58208,7 @@ var init_ConsumerExecutor = __esm({
         };
         this.processDistinctOn = async (consumer, dsSchema, datasetPath) => {
           Affirm_default(dsSchema, "Invalid dataset schema");
-          const reader = import_fs21.default.createReadStream(datasetPath);
+          const reader = import_fs22.default.createReadStream(datasetPath);
           const { distinctOn } = consumer.options;
           const { keys, resolution } = distinctOn;
           const { strategy, orderBy, direction = "asc" } = resolution;
@@ -57246,7 +58228,7 @@ var init_ConsumerExecutor = __esm({
             }
           }
           const tempWorkPath = datasetPath + "_tmp";
-          const writer = import_fs21.default.createWriteStream(tempWorkPath);
+          const writer = import_fs22.default.createWriteStream(tempWorkPath);
           const waitForDrain = () => new Promise((resolve) => writer.once("drain", resolve));
           for (const { line } of winners.values()) {
             if (!writer.write(line + "\n"))
@@ -57283,7 +58265,7 @@ var init_ConsumerExecutor = __esm({
           if (!pivotValues) {
             pivotValues = [];
             const discoverySet = /* @__PURE__ */ new Set();
-            const discoverReader = import_fs21.default.createReadStream(datasetPath);
+            const discoverReader = import_fs22.default.createReadStream(datasetPath);
             for await (const line of readLines(discoverReader)) {
               const record = parseLine(line);
               const val = String(record[pivotColumn] ?? "");
@@ -57300,7 +58282,7 @@ var init_ConsumerExecutor = __esm({
             }
           }
           const groups = /* @__PURE__ */ new Map();
-          const reader = import_fs21.default.createReadStream(datasetPath);
+          const reader = import_fs22.default.createReadStream(datasetPath);
           for await (const line of readLines(reader)) {
             const record = parseLine(line);
             const compositeKey = rowKeys.map((k7) => String(record[k7] ?? "")).join("|");
@@ -57324,7 +58306,7 @@ var init_ConsumerExecutor = __esm({
           const pivotedDsSchema = DatasetSchema_default.forPivot(dsSchema, rowKeys, pivotValues.map((pv) => columnPrefix + pv), groups.size);
           const outputPlan = OutputExecutor_default.compileOutput(consumer, pivotedDsSchema);
           const tempWorkPath = datasetPath + "_tmp";
-          const writer = import_fs21.default.createWriteStream(tempWorkPath);
+          const writer = import_fs22.default.createWriteStream(tempWorkPath);
           const waitForDrain = () => new Promise((resolve) => writer.once("drain", resolve));
           let outputCount = 0;
           for (const { rowRecord, cells } of groups.values()) {
@@ -57415,7 +58397,7 @@ var init_ConsumerExecutor = __esm({
           for (const fieldKey of uniqueFieldKeys) {
             fieldValueSets.set(fieldKey, /* @__PURE__ */ new Set());
           }
-          const reader = import_fs21.default.createReadStream(datasetPath);
+          const reader = import_fs22.default.createReadStream(datasetPath);
           for await (const line of readLines(reader)) {
             rowCount++;
             if (checkDuplicateRows) {
@@ -57562,10 +58544,10 @@ var init_ExecutorPerformance = __esm({
 });
 
 // ../../packages/executors/src/ExecutorWriter.ts
-var fs27, ExecutorWriter, ExecutorWriter_default;
+var fs28, ExecutorWriter, ExecutorWriter_default;
 var init_ExecutorWriter = __esm({
   "../../packages/executors/src/ExecutorWriter.ts"() {
-    fs27 = __toESM(require("fs"));
+    fs28 = __toESM(require("fs"));
     init_src();
     init_src3();
     init_src10();
@@ -57617,7 +58599,7 @@ var init_ExecutorWriter = __esm({
           await this._route(pass, dsSchema);
           if (pass.buckets.size === 0)
             return [{ path: sourcePath, label: this.UNSPLIT_LABEL }];
-          await fs27.promises.unlink(sourcePath);
+          await fs28.promises.unlink(sourcePath);
           return this._listFiles(pass);
         };
         /**
@@ -57625,7 +58607,7 @@ var init_ExecutorWriter = __esm({
          */
         this._route = async (pass, dsSchema) => {
           const parseLine = pass.keys.length === 0 ? null : LineParser_default.datasetParser(dsSchema);
-          const readStream = fs27.createReadStream(pass.sourcePath);
+          const readStream = fs28.createReadStream(pass.sourcePath);
           try {
             for await (const line of readLines(readStream)) {
               const bucket = this._bucketFor(line, pass, parseLine);
@@ -57729,7 +58711,7 @@ var init_ExecutorWriter = __esm({
           }
           if (pass.openStreams.length >= Constants_default.defaults.MAX_OPEN_SPLIT_STREAMS)
             await this._closeStream(pass.openStreams.shift());
-          bucket.stream = fs27.createWriteStream(this.getCompletedPath(pass.sourcePath, this._composeLabel(bucket, pass)), { flags: "a" });
+          bucket.stream = fs28.createWriteStream(this.getCompletedPath(pass.sourcePath, this._composeLabel(bucket, pass)), { flags: "a" });
           pass.openStreams.push(bucket);
           return bucket.stream;
         };
@@ -58007,10 +58989,10 @@ var init_OrchestratorHelper = __esm({
 });
 
 // ../../packages/executors/src/LookupResolver.ts
-var import_fs22, import_promises17, import_path22, LookupResolverClass, LookupResolver, LookupResolver_default;
+var import_fs23, import_promises17, import_path22, LookupResolverClass, LookupResolver, LookupResolver_default;
 var init_LookupResolver = __esm({
   "../../packages/executors/src/LookupResolver.ts"() {
-    import_fs22 = __toESM(require("fs"));
+    import_fs23 = __toESM(require("fs"));
     import_promises17 = __toESM(require("fs/promises"));
     import_path22 = __toESM(require("path"));
     init_src();
@@ -58088,7 +59070,7 @@ var init_LookupResolver = __esm({
           const dict = {};
           let rowsRead = 0;
           let warnedDup = false;
-          for await (const line of readLines(import_fs22.default.createReadStream(capture.path))) {
+          for await (const line of readLines(import_fs23.default.createReadStream(capture.path))) {
             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})`);
@@ -58127,10 +59109,10 @@ var init_LookupResolver = __esm({
 });
 
 // ../../packages/executors/src/ConsumerInputResolver.ts
-var import_fs23, import_promises18, import_path23, ConsumerInputResolverClass, ConsumerInputResolver, ConsumerInputResolver_default;
+var import_fs24, import_promises18, import_path23, ConsumerInputResolverClass, ConsumerInputResolver, ConsumerInputResolver_default;
 var init_ConsumerInputResolver = __esm({
   "../../packages/executors/src/ConsumerInputResolver.ts"() {
-    import_fs23 = __toESM(require("fs"));
+    import_fs24 = __toESM(require("fs"));
     import_promises18 = __toESM(require("fs/promises"));
     import_path23 = __toESM(require("path"));
     init_src();
@@ -58154,7 +59136,7 @@ var init_ConsumerInputResolver = __esm({
           Affirm_default(stack.length <= Constants_default.defaults.MAX_CONSUMER_INPUT_DEPTH, `consumer-as-input nesting exceeds MAX_CONSUMER_INPUT_DEPTH (${Constants_default.defaults.MAX_CONSUMER_INPUT_DEPTH}): ${stack.join(" -> ")}`);
           for (const name of upstreamNames) {
             const cached = this.cache.get(name);
-            if (!cached || !import_fs23.default.existsSync(cached.path)) {
+            if (!cached || !import_fs24.default.existsSync(cached.path)) {
               Affirm_default(!stack.includes(name), `consumer-as-input cycle detected: ${[...stack, name].join(" -> ")}`);
               const upstream = Environment_default.getConsumer(name);
               Affirm_default(upstream, `consumer-as-input references unknown consumer "${name}"`);
@@ -58233,10 +59215,10 @@ var ExecutorOrchestrator_exports = {};
 __export(ExecutorOrchestrator_exports, {
   default: () => ExecutorOrchestrator_default
 });
-var import_fs24, import_promises19, import_path24, import_workerpool, import_promises20, ExecutorOrchestratorClass, ExecutorOrchestrator, ExecutorOrchestrator_default;
+var import_fs25, import_promises19, import_path24, import_workerpool, import_promises20, ExecutorOrchestratorClass, ExecutorOrchestrator, ExecutorOrchestrator_default;
 var init_ExecutorOrchestrator = __esm({
   "../../packages/executors/src/ExecutorOrchestrator.ts"() {
-    import_fs24 = __toESM(require("fs"));
+    import_fs25 = __toESM(require("fs"));
     import_promises19 = __toESM(require("fs/promises"));
     import_path24 = __toESM(require("path"));
     import_workerpool = __toESM(require("workerpool"));
@@ -58425,15 +59407,17 @@ var init_ExecutorOrchestrator = __esm({
             _progress.update({ phase: "Exporting result", progress: 0 });
             counter = performance.now();
             Logger_default.info(`[${usageId}] Exporting results to ${consumer.outputs.length} output(s)`);
-            const exportRes = await OutputExecutor_default.exportResult(consumer, dsSchema, splitFiles);
+            const localExportPath = request.syntheticExportPath ? import_path24.default.join(request.syntheticExportPath, consumer.name) : void 0;
+            const exportRes = await OutputExecutor_default.exportResult(consumer, dsSchema, splitFiles, localExportPath);
             tracker.measure("export-result", performance.now() - counter);
-            Affirm_default(exportRes.res, `Consumer "${consumer.name}" failed to write its output to "${consumer.outputs.map((x2) => x2.exportDestination).join(", ")}" \u2014 see the logged driver error for the cause`);
+            const writtenTo = localExportPath ?? consumer.outputs.map((x2) => x2.exportDestination).join(", ");
+            Affirm_default(exportRes.res, `Consumer "${consumer.name}" failed to write its output to "${writtenTo}" \u2014 see the logged driver error for the cause`);
             Logger_default.info(`[${usageId}] Export complete in ${Math.round(performance.now() - counter)}ms (key: ${exportRes.key})`);
             _progress.update({ phase: "Exporting result", progress: 1 });
             if (consumer.outputs.some((x2) => x2.onSuccess)) {
               Logger_default.log(`[${usageId}] Running on-success actions`);
               counter = performance.now();
-              await ConsumerOnFinishManager_default.onConsumerSuccess(consumer, usageId, this.makeOnFinishRunner(consumer, request, usageId));
+              await ConsumerOnFinishManager_default.onConsumerSuccess(consumer, usageId, this.makeOnFinishRunner(consumer, request, usageId), { skipFileMoves: !!request.syntheticExportPath });
               tracker.measure("on-success-actions", performance.now() - counter);
               Logger_default.log(`[${usageId}] On-success actions complete in ${Math.round(performance.now() - counter)}ms`);
             }
@@ -58452,7 +59436,7 @@ var init_ExecutorOrchestrator = __esm({
             Logger_default.log(`[${usageId}] Consumer "${consumer.name}" failed: ${Helper_default.asError(error).message} | ${OrchestratorHelper_default.formatMemoryUsage()}`);
             Logger_default.error(error);
             if (!request.skipExport)
-              await ConsumerOnFinishManager_default.onConsumerError(consumer, usageId, this.makeOnFinishRunner(consumer, request, usageId));
+              await ConsumerOnFinishManager_default.onConsumerError(consumer, usageId, this.makeOnFinishRunner(consumer, request, usageId), { skipFileMoves: !!request.syntheticExportPath });
             Logger_default.log(`[${usageId}] Running cleanup after failure`);
             await this.performCleanupOperations(scope, tracker);
             UsageManager_default.failUsage(usageId, Helper_default.asError(error).message);
@@ -58473,7 +59457,7 @@ var init_ExecutorOrchestrator = __esm({
               Logger_default.info(`[${usageId}] Producer "${prod.name}": source returned no files, skipping`);
               continue;
             }
-            if (!import_fs24.default.existsSync(response.files[0].fullUri)) {
+            if (!import_fs25.default.existsSync(response.files[0].fullUri)) {
               if (!cProd.isOptional)
                 throw new Error(`Expected data file ${response.files[0].fullUri} of producer ${prod.name} in consumer ${consumer.name} is missing.`);
               Logger_default.info(`[${usageId}] Producer "${prod.name}": data file missing but marked optional, skipping`);
@@ -58628,7 +59612,8 @@ var init_ExecutorOrchestrator = __esm({
               details: { invokedBy: "ON_FINISH", user: request.details.user },
               logProgress: request.logProgress,
               _onFinishStack: chain2,
-              syntheticProducerInputs: request.syntheticProducerInputs
+              syntheticProducerInputs: request.syntheticProducerInputs,
+              syntheticExportPath: request.syntheticExportPath
             });
           };
         };
@@ -58638,7 +59623,7 @@ var init_ExecutorOrchestrator = __esm({
          * Returns a single chunk for small files where parallelism overhead isn't worth it.
          */
         this.scopeWork = (fileUri, numChunks) => {
-          const fileSize = import_fs24.default.statSync(fileUri).size;
+          const fileSize = import_fs25.default.statSync(fileUri).size;
           if (fileSize === 0) return [];
           if (fileSize < Constants_default.defaults.MIN_FILE_SIZE_FOR_PARALLEL) {
             return [{ start: 0, end: fileSize, isFirstChunk: true, fileUri, index: 0 }];
@@ -58648,7 +59633,7 @@ var init_ExecutorOrchestrator = __esm({
           const effectiveChunks = Math.min(targetWorkers, maxChunksBySize);
           if (effectiveChunks <= 1) return [{ start: 0, end: fileSize, isFirstChunk: true, fileUri, index: 0 }];
           const targetChunkSize = Math.floor(fileSize / effectiveChunks);
-          const fd = import_fs24.default.openSync(fileUri, "r");
+          const fd = import_fs25.default.openSync(fileUri, "r");
           try {
             const offsets = [];
             let currentStart = 0;
@@ -58666,7 +59651,7 @@ var init_ExecutorOrchestrator = __esm({
             }
             return offsets;
           } finally {
-            import_fs24.default.closeSync(fd);
+            import_fs25.default.closeSync(fd);
           }
         };
         /**
@@ -58734,7 +59719,7 @@ var init_ExecutorOrchestrator = __esm({
           let currentPos = position;
           while (currentPos < fileSize) {
             const bytesToRead = Math.min(BUFFER_SIZE, fileSize - currentPos);
-            const bytesRead = import_fs24.default.readSync(fd, buffer, 0, bytesToRead, currentPos);
+            const bytesRead = import_fs25.default.readSync(fd, buffer, 0, bytesToRead, currentPos);
             if (bytesRead === 0) break;
             for (let i6 = 0; i6 < bytesRead; i6++) {
               if (buffer[i6] === 10) {
@@ -58759,9 +59744,9 @@ var init_ExecutorOrchestrator = __esm({
             return;
           }
           const parseLine = LineParser_default.datasetParser(dsSchema);
-          const output = import_fs24.default.createWriteStream(targetPath);
+          const output = import_fs25.default.createWriteStream(targetPath);
           try {
-            for await (const line of readLines(import_fs24.default.createReadStream(sourcePath))) {
+            for await (const line of readLines(import_fs25.default.createReadStream(sourcePath))) {
               if (!line.length) continue;
               const record = parseLine(line);
               if (!output.write(JSON.stringify(record) + "\n"))
@@ -58859,7 +59844,7 @@ var init_ExecutorOrchestrator = __esm({
                 });
                 await (0, import_promises20.pipeline)(
                   xlsCsvStream,
-                  import_fs24.default.createWriteStream(decodedPath)
+                  import_fs25.default.createWriteStream(decodedPath)
                 );
                 const fileStats = await import_promises19.default.stat(decodedPath);
                 decodedFiles.push({ fullUri: decodedPath, fileSize: fileStats.size });
@@ -58919,8 +59904,8 @@ var init_ExecutorOrchestrator = __esm({
             const perf = performance.now();
             for (const workerResult of executorResults) {
               await (0, import_promises20.pipeline)(
-                import_fs24.default.createReadStream(workerResult.resultUri),
-                import_fs24.default.createWriteStream(mainPath, { flags: "a" })
+                import_fs25.default.createReadStream(workerResult.resultUri),
+                import_fs25.default.createWriteStream(mainPath, { flags: "a" })
               );
               await import_promises19.default.unlink(workerResult.resultUri);
             }
@@ -59176,7 +60161,7 @@ init_OutputExecutor();
 init_ProducerExecutor();
 
 // ../../packages/executors/src/SampleRunner.ts
-var import_fs25 = __toESM(require("fs"));
+var import_fs26 = __toESM(require("fs"));
 var import_promises21 = __toESM(require("fs/promises"));
 var import_path25 = __toESM(require("path"));
 init_src();
@@ -59290,9 +60275,9 @@ var SampleRunnerClass = class {
     };
     /** The captured dataset, which `captureFormat: 'JSONL'` guarantees is one JSON object per line. */
     this._readCapture = async (capturePath, size) => {
-      if (!import_fs25.default.existsSync(capturePath)) return [];
+      if (!import_fs26.default.existsSync(capturePath)) return [];
       const records = [];
-      for await (const line of readLines(import_fs25.default.createReadStream(capturePath))) {
+      for await (const line of readLines(import_fs26.default.createReadStream(capturePath))) {
         if (!line.length) continue;
         records.push(JSON.parse(line));
         if (records.length >= size) break;
@@ -59309,11 +60294,11 @@ init_src2();
 
 // src/paths.ts
 var import_path26 = __toESM(require("path"));
-var import_fs26 = __toESM(require("fs"));
+var import_fs27 = __toESM(require("fs"));
 init_src3();
 var resolveAssetDir = (name) => {
   const bundledPath = import_path26.default.join(__dirname, name);
-  if (import_fs26.default.existsSync(bundledPath)) return bundledPath;
+  if (import_fs27.default.existsSync(bundledPath)) return bundledPath;
   return import_path26.default.join(__dirname, "..", name);
 };
 var DOCUMENTATION_DIR = resolveAssetDir("documentation");
@@ -59375,9 +60360,13 @@ var printFixedLayout = (report4) => {
     console.log(import_chalk2.default.blue(`  ${name}: ${layout.plan.recordLength} characters, ${layout.plan.fields.length} field(s)`));
     console.log(import_chalk2.default.gray(`    ${column("start")}  ${column("end")}  ${column("width")}  field`));
     for (const field of layout.plan.fields)
-      console.log(import_chalk2.default.gray(`    ${column(field.start)}  ${column(field.end)}  ${column(field.width)}  `) + field.name);
+      console.log(import_chalk2.default.gray(`    ${column(field.start)}  ${column(field.end)}  ${column(field.width)}  `) + field.name + import_chalk2.default.gray(spelling(field)));
   }
 };
+var spelling = (field) => {
+  const parts = [field.scale ? `${field.scale} implied decimal(s)` : null, field.sign ? `${field.sign} sign` : null].filter(Boolean);
+  return parts.length > 0 ? `  (${parts.join(", ")})` : "";
+};
 var column = (value) => String(value).padStart(5);
 
 // src/actions/verify.ts
@@ -59437,7 +60426,7 @@ var verify = async (options2) => {
 
 // src/actions/deploy.ts
 var import_chalk5 = __toESM(require("chalk"));
-var import_fs28 = __toESM(require("fs"));
+var import_fs29 = __toESM(require("fs"));
 var import_path28 = __toESM(require("path"));
 init_src3();
 init_src4();
@@ -59445,7 +60434,7 @@ init_src2();
 
 // src/actions/package_config.ts
 var import_chalk4 = __toESM(require("chalk"));
-var import_fs27 = __toESM(require("fs"));
+var import_fs28 = __toESM(require("fs"));
 var import_path27 = __toESM(require("path"));
 init_src4();
 init_src2();
@@ -59454,7 +60443,7 @@ var package_config = async (output) => {
   try {
     await compile();
     const target = import_path27.default.resolve(output || DEFAULT_OUTPUT);
-    const replaced = import_fs27.default.existsSync(target);
+    const replaced = import_fs28.default.existsSync(target);
     const built = ConfigPackager_default.write("./remora", target);
     const sizeKB = (built.bytes / 1024).toFixed(1);
     console.log(import_chalk4.default.green(`\u2705 ${replaced ? "Replaced" : "Created"} configuration package: `) + import_chalk4.default.yellow(built.path));
@@ -59479,7 +60468,7 @@ var deploy = async (options2) => {
     const tempZipPath = import_path28.default.join(process.cwd(), "temp_deployment.zip");
     ConfigPackager_default.write("./remora", tempZipPath);
     try {
-      const zipBuffer = import_fs28.default.readFileSync(tempZipPath);
+      const zipBuffer = import_fs29.default.readFileSync(tempZipPath);
       const host = ProcessENVManager_default.getEnvVariable("REMORA_WORKER_HOST");
       const version = Constants_default.workerVersion;
       const workerAPI = `${host}/cli/v${version}/uploaddeployment`;
@@ -59501,7 +60490,7 @@ var deploy = async (options2) => {
       }
       console.log(import_chalk5.default.green("\u2705 Deployment package uploaded successfully"));
     } finally {
-      import_fs28.default.unlinkSync(tempZipPath);
+      import_fs29.default.unlinkSync(tempZipPath);
     }
   } catch (error) {
     console.error(import_chalk5.default.red("\u274C Deployment error:"), error instanceof Error ? error.message : String(error));
@@ -59552,16 +60541,17 @@ var ensureEnvRuntimeContext = async () => {
   await import_fs_extra2.default.appendFile(envPath, `${prefix2}${line}
 `);
 };
+var GENERATED_FOLDERS = ["remora/.temp", "remora/.synth"];
 var ensureGitignoreEntry = async () => {
   const gitignorePath = ".gitignore";
-  const entry = "remora/.temp";
   const exists = await import_fs_extra2.default.pathExists(gitignorePath);
   const current = exists ? await import_fs_extra2.default.readFile(gitignorePath, "utf-8") : "";
-  const isIgnored = current.split("\n").some((row) => row.trim() === entry);
-  if (isIgnored)
+  const rows = current.split("\n").map((row) => row.trim());
+  const missing = GENERATED_FOLDERS.filter((entry) => !rows.includes(entry));
+  if (missing.length === 0)
     return;
   const prefix2 = current.length && !current.endsWith("\n") ? "\n" : "";
-  await import_fs_extra2.default.appendFile(gitignorePath, `${prefix2}${entry}
+  await import_fs_extra2.default.appendFile(gitignorePath, `${prefix2}${missing.join("\n")}
 `);
 };
 var init = async () => {
@@ -59607,7 +60597,7 @@ var init = async () => {
     console.log(import_chalk6.default.green("\u{1F4C1} A new folder named ") + import_chalk6.default.cyan("remora/") + import_chalk6.default.green(" has been created in your project."));
     console.log(import_chalk6.default.green("\u270F\uFE0F  Customize the generated configuration files inside this folder to setup Remora."));
     console.log(import_chalk6.default.gray("   \u2022 REMORA_RUNTIME_CONTEXT=cli was added to your .env"));
-    console.log(import_chalk6.default.gray("   \u2022 remora/.temp was added to your .gitignore"));
+    console.log(import_chalk6.default.gray(`   \u2022 ${GENERATED_FOLDERS.join(" and ")} were added to your .gitignore`));
     console.log(import_chalk6.default.green("\n\u{1F463} Next step: set your environment variables (add these to your .env file):"));
     console.log(import_chalk6.default.blue("\u2022 REMORA_LICENCE_KEY") + import_chalk6.default.gray(" \u2192 Your valid Remora licence key (required to run any command)"));
     console.log(import_chalk6.default.blue("\u2022 OPENAI_API_KEY") + import_chalk6.default.gray(" \u2192 Optional, enables AI features (discover, automap)"));
@@ -59620,10 +60610,15 @@ var init = async () => {
 };
 
 // src/actions/run.ts
-var import_chalk7 = __toESM(require("chalk"));
+var import_chalk8 = __toESM(require("chalk"));
 init_src4();
 init_src5();
 
+// src/licence.ts
+var import_chalk7 = __toESM(require("chalk"));
+var import_dayjs5 = __toESM(require("dayjs"));
+init_src4();
+
 // ../../packages/auth/src/AdminManager.ts
 init_src();
 init_src9();
@@ -59798,8 +60793,64 @@ var LicenceManagerClass = class {
 var LicenceManager = new LicenceManagerClass();
 var LicenceManager_default = LicenceManager;
 
+// src/licence.ts
+var readKey = () => {
+  try {
+    return ProcessENVManager_default.getEnvVariable("REMORA_LICENCE_KEY");
+  } catch {
+    return null;
+  }
+};
+var print = (headline, body) => {
+  console.error("");
+  console.error(`  ${import_chalk7.default.red("\u2716")}  ${import_chalk7.default.red.bold(headline)}`);
+  console.error("");
+  for (const line of body)
+    console.error(line ? `     ${line}` : "");
+  console.error("");
+};
+var explainMissing = () => print("Remora needs a licence key to run.", [
+  `${import_chalk7.default.cyan("REMORA_LICENCE_KEY")} is not set in this environment.`,
+  "",
+  `Add it to the ${import_chalk7.default.cyan(".env")} file beside your project folder:`,
+  "",
+  import_chalk7.default.gray("  REMORA_LICENCE_KEY=your-licence-key"),
+  "",
+  "or export it in your shell:",
+  "",
+  import_chalk7.default.gray("  export REMORA_LICENCE_KEY=your-licence-key"),
+  "",
+  import_chalk7.default.gray("No key yet? Ask whoever set Remora up for your team.")
+]);
+var explainExpired = (expiry) => print(`Your Remora licence expired on ${(0, import_dayjs5.default)(expiry).format("D MMMM YYYY")}.`, [
+  "Renew the licence, then replace the key held in",
+  `${import_chalk7.default.cyan("REMORA_LICENCE_KEY")} with the new one.`
+]);
+var explainUnrecognised = () => print("This Remora licence key is not recognised.", [
+  `The key in ${import_chalk7.default.cyan("REMORA_LICENCE_KEY")} is not signed by Forza Labs.`,
+  "Check it was copied whole \u2014 a licence key is one unbroken line,",
+  "with no spaces and no line breaks."
+]);
+var explainMalformed = () => print("This Remora licence key cannot be read.", [
+  `The value of ${import_chalk7.default.cyan("REMORA_LICENCE_KEY")} is not a well-formed key.`,
+  "Check it was copied whole \u2014 a licence key is one unbroken line,",
+  "with no spaces and no line breaks."
+]);
+var assertLicence = () => {
+  const key = readKey();
+  if (!key) {
+    explainMissing();
+    process.exit(1);
+  }
+  const check = LicenceManager_default.validate(key);
+  if (check.valid) return check;
+  if (check.expiryDate) explainExpired(check.expiryDate);
+  else if (check.reason === "Invalid license signature") explainUnrecognised();
+  else explainMalformed();
+  process.exit(1);
+};
+
 // src/actions/run.ts
-init_src4();
 init_src2();
 var run = async (consumerName, options2) => {
   try {
@@ -59822,29 +60873,24 @@ var run = async (consumerName, options2) => {
       consumersToExecute.push(...Environment_default._env.consumers);
     }
     if (consumersToExecute.length === 1)
-      console.log(import_chalk7.default.blue(`Running consumer ${consumersToExecute[0].name}...
+      console.log(import_chalk8.default.blue(`Running consumer ${consumersToExecute[0].name}...
 `));
     else
-      console.log(import_chalk7.default.blue(`Running consumers ${consumersToExecute.map((x2) => x2.name).join(", ")}...
+      console.log(import_chalk8.default.blue(`Running consumers ${consumersToExecute.map((x2) => x2.name).join(", ")}...
 `));
     if (options2?.limit)
-      console.log(import_chalk7.default.gray(`Limiting output to ${options2.limit} records
+      console.log(import_chalk8.default.gray(`Limiting output to ${options2.limit} records
 `));
     const results = [];
     for (let i6 = 0; i6 < consumersToExecute.length; i6++) {
       const consumer = consumersToExecute[i6];
       try {
-        const remoraLicenceKey2 = ProcessENVManager_default.getEnvVariable("REMORA_LICENCE_KEY");
-        const check2 = LicenceManager_default.validate(remoraLicenceKey2);
-        if (!check2.valid) {
-          console.error(`Invalid Remora licence key, the product is not active: remember to set "REMORA_LICENCE_KEY" environment variable.`);
-          process.exit(1);
-        }
+        const check = assertLicence();
         const response = await ExecutorOrchestrator_default.launch({
           consumer,
           details: {
             invokedBy: "CLI",
-            user: { _id: check2.customer, name: check2.customer, type: "licence" }
+            user: { _id: check.customer, name: check.customer, type: "licence" }
           },
           options: options2?.limit ? { limit: options2.limit } : void 0,
           logProgress: true
@@ -59865,20 +60911,20 @@ var run = async (consumerName, options2) => {
         const { elapsedMS, outputCount, resultUri } = response;
         const rowCount = outputCount;
         const duration = Helper_default.formatDuration(elapsedMS);
-        const performanceInfo = import_chalk7.default.gray(` (${rowCount} rows, ${duration})`);
+        const performanceInfo = import_chalk8.default.gray(` (${rowCount} rows, ${duration})`);
         if (resultUri)
-          console.log(import_chalk7.default.green(`\u2022 Consumer ${consumer.name} -> ${resultUri}`) + performanceInfo);
+          console.log(import_chalk8.default.green(`\u2022 Consumer ${consumer.name} -> ${resultUri}`) + performanceInfo);
         else
-          console.log(import_chalk7.default.green(`\u2022 Consumer ${consumer.name} `) + performanceInfo);
+          console.log(import_chalk8.default.green(`\u2022 Consumer ${consumer.name} `) + performanceInfo);
       } else {
-        console.log(import_chalk7.default.red(`\u2022 Consumer ${consumer.name} -> Failed`));
+        console.log(import_chalk8.default.red(`\u2022 Consumer ${consumer.name} -> Failed`));
       }
     });
     const failedResults = results.filter((x2) => !x2.success);
     if (failedResults.length > 0) {
-      console.log(import_chalk7.default.red("\nError details:"));
+      console.log(import_chalk8.default.red("\nError details:"));
       failedResults.forEach((result, index) => {
-        console.log(import_chalk7.default.red(`  ${index + 1}. ${result.consumer.name}: ${result.error}`));
+        console.log(import_chalk8.default.red(`  ${index + 1}. ${result.consumer.name}: ${result.error}`));
       });
     }
     const successfulResults = results.filter((x2) => x2.success);
@@ -59888,17 +60934,17 @@ var run = async (consumerName, options2) => {
     const totalDuration = successfulResults.reduce((sum, result) => {
       return sum + (result.response?.elapsedMS || 0);
     }, 0);
-    const totalsInfo = import_chalk7.default.gray(` (${totalRows} rows, ${Helper_default.formatDuration(totalDuration)})`);
+    const totalsInfo = import_chalk8.default.gray(` (${totalRows} rows, ${Helper_default.formatDuration(totalDuration)})`);
     const hasFailures = results.some((x2) => !x2.success);
     if (hasFailures)
-      console.log(import_chalk7.default.blueBright("\n\u2139\uFE0F Run completed with errors") + totalsInfo);
+      console.log(import_chalk8.default.blueBright("\n\u2139\uFE0F Run completed with errors") + totalsInfo);
     else
-      console.log(import_chalk7.default.green("\n\u2705 Run complete!") + totalsInfo);
+      console.log(import_chalk8.default.green("\n\u2705 Run complete!") + totalsInfo);
     await Logger_default.flush();
     process.exit(hasFailures ? 1 : 0);
   } catch (err2) {
     const myErr = Helper_default.asError(err2);
-    console.error(import_chalk7.default.red.bold("\n\u274C Unexpected error during run:"), myErr.message);
+    console.error(import_chalk8.default.red.bold("\n\u274C Unexpected error during run:"), myErr.message);
     Logger_default.error(myErr);
     await Logger_default.flush();
     process.exit(1);
@@ -59906,24 +60952,24 @@ var run = async (consumerName, options2) => {
 };
 
 // src/actions/report.ts
-var import_chalk8 = __toESM(require("chalk"));
+var import_chalk9 = __toESM(require("chalk"));
 init_src10();
 init_src5();
 init_src2();
 var report = async (runId, options2 = {}) => {
   try {
-    console.log(import_chalk8.default.blue(runId ? `Collecting a bug report for run ${runId}...` : "Collecting a bug report for the last recorded run..."));
+    console.log(import_chalk9.default.blue(runId ? `Collecting a bug report for run ${runId}...` : "Collecting a bug report for the last recorded run..."));
     const result = BugReportService_default.collect({ runId, outputPath: options2.output });
     const { manifest } = result;
-    console.log(import_chalk8.default.green("\n\u2705 Bug report written: ") + import_chalk8.default.yellow(result.path));
-    console.log(import_chalk8.default.blue(`   ${manifest.files.length} files, ${(result.bytes / 1024).toFixed(1)} KB, bundle ${manifest.bundleId}`));
-    console.log(import_chalk8.default.blue("   Run: ") + (manifest.runId ? import_chalk8.default.yellow(`${manifest.consumer} (${manifest.runId})`) : import_chalk8.default.yellow("none \u2014 no local run history, so the bundle reports the project as it stands")));
+    console.log(import_chalk9.default.green("\n\u2705 Bug report written: ") + import_chalk9.default.yellow(result.path));
+    console.log(import_chalk9.default.blue(`   ${manifest.files.length} files, ${(result.bytes / 1024).toFixed(1)} KB, bundle ${manifest.bundleId}`));
+    console.log(import_chalk9.default.blue("   Run: ") + (manifest.runId ? import_chalk9.default.yellow(`${manifest.consumer} (${manifest.runId})`) : import_chalk9.default.yellow("none \u2014 no local run history, so the bundle reports the project as it stands")));
     printSections(manifest.sections);
-    console.log(import_chalk8.default.blue("\nIt holds no customer data: only configuration travels, and the log is scrubbed of credential shapes."));
-    console.log(import_chalk8.default.blue("Read ") + import_chalk8.default.yellow("report.md") + import_chalk8.default.blue(" inside it, then attach the archive where you report the problem."));
+    console.log(import_chalk9.default.blue("\nIt holds no customer data: only configuration travels, and the log is scrubbed of credential shapes."));
+    console.log(import_chalk9.default.blue("Read ") + import_chalk9.default.yellow("report.md") + import_chalk9.default.blue(" inside it, then attach the archive where you report the problem."));
     await Logger_default.flush();
   } catch (error) {
-    console.error(import_chalk8.default.red.bold("\n\u274C Could not write the bug report:"), Helper_default.asError(error).message);
+    console.error(import_chalk9.default.red.bold("\n\u274C Could not write the bug report:"), Helper_default.asError(error).message);
     Logger_default.error(error);
     await Logger_default.flush();
     process.exit(1);
@@ -59932,14 +60978,14 @@ var report = async (runId, options2 = {}) => {
 var printSections = (sections) => {
   console.log("");
   for (const section of sections) {
-    const mark = section.included ? import_chalk8.default.green("  \u2713 ") : import_chalk8.default.gray("  \xB7 ");
-    const reason = section.reason ? import_chalk8.default.gray(` \u2014 ${section.reason}`) : "";
-    console.log(mark + import_chalk8.default.white(section.name.padEnd(12)) + reason);
+    const mark = section.included ? import_chalk9.default.green("  \u2713 ") : import_chalk9.default.gray("  \xB7 ");
+    const reason = section.reason ? import_chalk9.default.gray(` \u2014 ${section.reason}`) : "";
+    console.log(mark + import_chalk9.default.white(section.name.padEnd(12)) + reason);
   }
 };
 
 // src/actions/discover.ts
-var import_chalk9 = __toESM(require("chalk"));
+var import_chalk10 = __toESM(require("chalk"));
 var import_ora4 = __toESM(require("ora"));
 init_src4();
 init_src10();
@@ -59947,17 +60993,17 @@ init_src2();
 var discover = async (producerName, options2) => {
   try {
     compile();
-    const spinner = (0, import_ora4.default)(import_chalk9.default.blue("Discovering producer...\n")).start();
+    const spinner = (0, import_ora4.default)(import_chalk10.default.blue("Discovering producer...\n")).start();
     const producer = Environment_default.getProducer(producerName);
     const mode = options2?.replace ? "replace" : "merge";
     const result = await DeveloperEngine_default.discover(producer, mode);
     spinner.succeed("Producer has been successfully discovered");
     reportDiscovery(result.report, mode);
-    console.log(import_chalk9.default.green("\n\u2705 Discovery complete!"));
+    console.log(import_chalk10.default.green("\n\u2705 Discovery complete!"));
     await Logger_default.flush();
     process.exit(0);
   } catch (err2) {
-    console.error(import_chalk9.default.red.bold("\n\u274C Unexpected error during discover:"), err2 instanceof Error ? err2.message : String(err2));
+    console.error(import_chalk10.default.red.bold("\n\u274C Unexpected error during discover:"), err2 instanceof Error ? err2.message : String(err2));
     Logger_default.error(err2);
     await Logger_default.flush();
     process.exit(1);
@@ -59966,21 +61012,21 @@ var discover = async (producerName, options2) => {
 var reportDiscovery = (report4, mode) => {
   console.log("");
   if (report4.added.length > 0)
-    console.log(import_chalk9.default.green(`  + ${report4.added.length} new dimension(s): ${report4.added.join(", ")}`));
+    console.log(import_chalk10.default.green(`  + ${report4.added.length} new dimension(s): ${report4.added.join(", ")}`));
   for (const { name, properties } of report4.filled)
-    console.log(import_chalk9.default.blue(`  ~ ${name}: filled in ${properties.join(", ")}`));
+    console.log(import_chalk10.default.blue(`  ~ ${name}: filled in ${properties.join(", ")}`));
   const onMismatch = mode === "replace" ? "rewritten to the source's" : "left as declared";
   for (const { name, declared, discovered } of report4.mismatched)
-    console.log(import_chalk9.default.yellow(`  ! ${name} is declared "${declared}" but the source reports "${discovered}" \u2014 ${onMismatch}`));
+    console.log(import_chalk10.default.yellow(`  ! ${name} is declared "${declared}" but the source reports "${discovered}" \u2014 ${onMismatch}`));
   if (report4.orphaned.length === 0) return;
   const verb = mode === "replace" ? "dropped" : "kept";
-  console.log(import_chalk9.default.yellow(`  ! ${report4.orphaned.length} dimension(s) the source has no field for, ${verb}: ${report4.orphaned.join(", ")}`));
+  console.log(import_chalk10.default.yellow(`  ! ${report4.orphaned.length} dimension(s) the source has no field for, ${verb}: ${report4.orphaned.join(", ")}`));
   if (mode !== "replace")
-    console.log(import_chalk9.default.gray("    Re-run with --replace to rewrite the dimensions from the source instead."));
+    console.log(import_chalk10.default.gray("    Re-run with --replace to rewrite the dimensions from the source instead."));
 };
 
 // src/actions/graph.ts
-var import_chalk10 = __toESM(require("chalk"));
+var import_chalk11 = __toESM(require("chalk"));
 init_src4();
 init_src3();
 init_src10();
@@ -59991,7 +61037,7 @@ var graph = async (options2) => {
   const format4 = options2?.format ?? "mermaid";
   try {
     if (!FORMATS.includes(format4)) {
-      console.error(import_chalk10.default.red(`Unknown format "${format4}". Use one of: ${FORMATS.join(", ")}.`));
+      console.error(import_chalk11.default.red(`Unknown format "${format4}". Use one of: ${FORMATS.join(", ")}.`));
       await Logger_default.flush();
       process.exit(1);
     }
@@ -60008,7 +61054,7 @@ var graph = async (options2) => {
       reportDiagnostics(snapshot.diagnostics);
   } catch (err2) {
     const myErr = Helper_default.asError(err2);
-    console.error(import_chalk10.default.red.bold("\n\u274C Error while building the project graph:"), myErr.message);
+    console.error(import_chalk11.default.red.bold("\n\u274C Error while building the project graph:"), myErr.message);
     Logger_default.error(err2);
     await Logger_default.flush();
     process.exit(1);
@@ -60023,14 +61069,14 @@ var reportDiagnostics = (diagnostics) => {
   const errors = diagnostics.filter((x2) => x2.severity === "error");
   const warnings = diagnostics.filter((x2) => x2.severity === "warning");
   if (errors.length === 0 && warnings.length === 0) return;
-  console.error(import_chalk10.default.gray(`
+  console.error(import_chalk11.default.gray(`
 ${errors.length} error(s), ${warnings.length} warning(s):`));
-  errors.forEach((x2) => console.error(import_chalk10.default.red(`  \u2022 ${x2.message}`)));
-  warnings.forEach((x2) => console.error(import_chalk10.default.yellow(`  \u2022 ${x2.message}`)));
+  errors.forEach((x2) => console.error(import_chalk11.default.red(`  \u2022 ${x2.message}`)));
+  warnings.forEach((x2) => console.error(import_chalk11.default.yellow(`  \u2022 ${x2.message}`)));
 };
 
 // src/actions/ui_preview.ts
-var import_chalk11 = __toESM(require("chalk"));
+var import_chalk12 = __toESM(require("chalk"));
 var import_node_fs11 = __toESM(require("fs"));
 var import_node_path16 = __toESM(require("path"));
 init_src4();
@@ -60062,7 +61108,7 @@ var ui_preview = async (options2) => {
     stopOnSignal(server, watch);
   } catch (err2) {
     const myErr = Helper_default.asError(err2);
-    console.error(import_chalk11.default.red.bold("\n\u274C Could not start the project preview:"), myErr.message);
+    console.error(import_chalk12.default.red.bold("\n\u274C Could not start the project preview:"), myErr.message);
     Logger_default.error(err2);
     await Logger_default.flush();
     process.exit(1);
@@ -60289,10 +61335,10 @@ var readPort = (value) => {
 var report2 = (server, snapshot) => {
   const errors = snapshot.diagnostics.filter((x2) => x2.severity === "error").length;
   const warnings = snapshot.diagnostics.filter((x2) => x2.severity === "warning").length;
-  console.log(import_chalk11.default.bold(`
-\u{1F50D} Preview of "${snapshot.project}" on ${import_chalk11.default.cyan(server.url)}`));
-  console.log(import_chalk11.default.gray(`   ${snapshot.graph.nodes.length} node(s), ${snapshot.graph.edges.length} edge(s), ${errors} error(s), ${warnings} warning(s)`));
-  console.log(import_chalk11.default.gray("   Watching the configuration and the run history for changes. Press Ctrl+C to stop.\n"));
+  console.log(import_chalk12.default.bold(`
+\u{1F50D} Preview of "${snapshot.project}" on ${import_chalk12.default.cyan(server.url)}`));
+  console.log(import_chalk12.default.gray(`   ${snapshot.graph.nodes.length} node(s), ${snapshot.graph.edges.length} edge(s), ${errors} error(s), ${warnings} warning(s)`));
+  console.log(import_chalk12.default.gray("   Watching the configuration and the run history for changes. Press Ctrl+C to stop.\n"));
 };
 var stopOnSignal = (server, watch) => {
   const stop = async () => {
@@ -60306,47 +61352,47 @@ var stopOnSignal = (server, watch) => {
 };
 
 // src/actions/create_producer.ts
-var import_chalk12 = __toESM(require("chalk"));
-var import_fs29 = __toESM(require("fs"));
+var import_chalk13 = __toESM(require("chalk"));
+var import_fs30 = __toESM(require("fs"));
 var import_path30 = __toESM(require("path"));
 init_src2();
 var create_producer = async (name) => {
   try {
-    if (!import_fs29.default.existsSync(PRODUCERS_DIR)) {
-      throw new Error(import_chalk12.default.red("Missing directory: ") + import_chalk12.default.yellow(PRODUCERS_DIR));
+    if (!import_fs30.default.existsSync(PRODUCERS_DIR)) {
+      throw new Error(import_chalk13.default.red("Missing directory: ") + import_chalk13.default.yellow(PRODUCERS_DIR));
     }
-    const defaultProducerTemplate = import_fs29.default.readFileSync(
+    const defaultProducerTemplate = import_fs30.default.readFileSync(
       import_path30.default.join(DOCUMENTATION_DIR, "default_resources/producer.json"),
       "utf-8"
     );
     const defaultProducer = JSON.parse(defaultProducerTemplate);
     defaultProducer.name = name;
     const producerPath = import_path30.default.join(PRODUCERS_DIR, `${name}.json`);
-    import_fs29.default.writeFileSync(producerPath, JSON.stringify(defaultProducer, null, 4));
-    console.log(import_chalk12.default.green(`\u2705 Created producer config at ${producerPath}`));
-    console.log(import_chalk12.default.blue("Remember to:"));
-    console.log(import_chalk12.default.blue("1. Set the correct source name"));
-    console.log(import_chalk12.default.blue(`2. Configure the dimensions, or run "remora discover ${name} --replace" to`));
-    console.log(import_chalk12.default.blue("   write them from the source over the placeholders this template ships with"));
-    console.log(import_chalk12.default.blue("3. Update the settings as needed"));
+    import_fs30.default.writeFileSync(producerPath, JSON.stringify(defaultProducer, null, 4));
+    console.log(import_chalk13.default.green(`\u2705 Created producer config at ${producerPath}`));
+    console.log(import_chalk13.default.blue("Remember to:"));
+    console.log(import_chalk13.default.blue("1. Set the correct source name"));
+    console.log(import_chalk13.default.blue(`2. Configure the dimensions, or run "remora discover ${name} --replace" to`));
+    console.log(import_chalk13.default.blue("   write them from the source over the placeholders this template ships with"));
+    console.log(import_chalk13.default.blue("3. Update the settings as needed"));
   } catch (error) {
-    console.error(import_chalk12.default.red("\u274C Error creating producer:"), error instanceof Error ? error.message : String(error));
+    console.error(import_chalk13.default.red("\u274C Error creating producer:"), error instanceof Error ? error.message : String(error));
     Logger_default.error(error);
     process.exit(1);
   }
 };
 
 // src/actions/create_consumer.ts
-var import_chalk13 = __toESM(require("chalk"));
-var import_fs30 = __toESM(require("fs"));
+var import_chalk14 = __toESM(require("chalk"));
+var import_fs31 = __toESM(require("fs"));
 var import_path31 = __toESM(require("path"));
 init_src2();
 var create_consumer = async (name, producerName) => {
   try {
-    if (!import_fs30.default.existsSync(CONSUMERS_DIR)) {
-      throw new Error(import_chalk13.default.red("Missing directory: ") + import_chalk13.default.yellow(CONSUMERS_DIR));
+    if (!import_fs31.default.existsSync(CONSUMERS_DIR)) {
+      throw new Error(import_chalk14.default.red("Missing directory: ") + import_chalk14.default.yellow(CONSUMERS_DIR));
     }
-    const defaultConsumerTemplate = import_fs30.default.readFileSync(
+    const defaultConsumerTemplate = import_fs31.default.readFileSync(
       import_path31.default.join(DOCUMENTATION_DIR, "default_resources/consumer.json"),
       "utf-8"
     );
@@ -60354,10 +61400,10 @@ var create_consumer = async (name, producerName) => {
     defaultConsumer.name = name;
     if (producerName) {
       const producerPath = import_path31.default.join(PRODUCERS_DIR, `${producerName}.json`);
-      if (!import_fs30.default.existsSync(producerPath)) {
-        throw new Error(import_chalk13.default.red("Producer not found: ") + import_chalk13.default.yellow(producerPath));
+      if (!import_fs31.default.existsSync(producerPath)) {
+        throw new Error(import_chalk14.default.red("Producer not found: ") + import_chalk14.default.yellow(producerPath));
       }
-      const producerConfig = JSON.parse(import_fs30.default.readFileSync(producerPath, "utf-8"));
+      const producerConfig = JSON.parse(import_fs31.default.readFileSync(producerPath, "utf-8"));
       defaultConsumer.producers = [{ name: producerName }];
       defaultConsumer.fields = producerConfig.dimensions.map((dim) => ({
         key: dim.name,
@@ -60370,43 +61416,79 @@ var create_consumer = async (name, producerName) => {
       defaultConsumer.metadata = void 0;
     }
     const consumerPath = import_path31.default.join(CONSUMERS_DIR, `${name}.json`);
-    import_fs30.default.writeFileSync(consumerPath, JSON.stringify(defaultConsumer, null, 4));
-    console.log(import_chalk13.default.green(`\u2705 Created consumer config at ${consumerPath}`));
+    import_fs31.default.writeFileSync(consumerPath, JSON.stringify(defaultConsumer, null, 4));
+    console.log(import_chalk14.default.green(`\u2705 Created consumer config at ${consumerPath}`));
     if (!producerName) {
-      console.log(import_chalk13.default.blue("Remember to:"));
-      console.log(import_chalk13.default.blue("1. Set the correct producer name"));
-      console.log(import_chalk13.default.blue("2. Configure the fields you want to include"));
-      console.log(import_chalk13.default.blue("3. Set up the desired output formats"));
+      console.log(import_chalk14.default.blue("Remember to:"));
+      console.log(import_chalk14.default.blue("1. Set the correct producer name"));
+      console.log(import_chalk14.default.blue("2. Configure the fields you want to include"));
+      console.log(import_chalk14.default.blue("3. Set up the desired output formats"));
     } else {
-      console.log(import_chalk13.default.blue("Consumer is configured to match all fields from producer:"), import_chalk13.default.yellow(producerName));
-      console.log(import_chalk13.default.blue("Remember to:"));
-      console.log(import_chalk13.default.blue("1. Review the included fields"));
-      console.log(import_chalk13.default.blue("2. Set up the desired output formats"));
+      console.log(import_chalk14.default.blue("Consumer is configured to match all fields from producer:"), import_chalk14.default.yellow(producerName));
+      console.log(import_chalk14.default.blue("Remember to:"));
+      console.log(import_chalk14.default.blue("1. Review the included fields"));
+      console.log(import_chalk14.default.blue("2. Set up the desired output formats"));
     }
   } catch (error) {
-    console.error(import_chalk13.default.red("\u274C Error creating consumer:"), error instanceof Error ? error.message : String(error));
+    console.error(import_chalk14.default.red("\u274C Error creating consumer:"), error instanceof Error ? error.message : String(error));
     Logger_default.error(error);
     process.exit(1);
   }
 };
 
+// src/actions/import_copybook.ts
+var import_chalk15 = __toESM(require("chalk"));
+var import_fs32 = __toESM(require("fs"));
+var import_path32 = __toESM(require("path"));
+init_src10();
+init_src2();
+var PRODUCER_SCHEMA = "https://raw.githubusercontent.com/ForzaLabs/remora-public/refs/heads/main/json_schemas/producer-schema.json";
+var import_copybook = async (file, options2 = {}) => {
+  try {
+    if (!import_fs32.default.existsSync(file))
+      throw new Error(`No copybook at ${file}`);
+    if (!import_fs32.default.existsSync(PRODUCERS_DIR))
+      throw new Error(`Missing directory: ${PRODUCERS_DIR}`);
+    const name = options2.name || defaultName(file);
+    const producerPath = import_path32.default.join(PRODUCERS_DIR, `${name}.json`);
+    if (import_fs32.default.existsSync(producerPath))
+      throw new Error(`${producerPath} already exists. Pass a different name with -n, or remove the file to replace it.`);
+    const layout = CopybookParser_default.parse(import_fs32.default.readFileSync(file, "utf-8"));
+    const { producer, notes } = CopybookEmitter_default.toProducer(layout, { name });
+    import_fs32.default.writeFileSync(producerPath, JSON.stringify({ $schema: PRODUCER_SCHEMA, ...producer }, null, 4));
+    console.log(import_chalk15.default.green(`\u2705 Created producer config at ${producerPath}`));
+    console.log(import_chalk15.default.blue(`Record ${layout.name}: ${layout.width} characters, ${producer.dimensions.length} dimension(s).`));
+    notes.forEach((note) => console.log(import_chalk15.default.yellow(`\u2022 ${note}`)));
+    console.log(import_chalk15.default.blue('Remember to set the source and the fileKey, then run "remora compile".'));
+  } catch (error) {
+    console.error(import_chalk15.default.red("\u274C Error importing copybook:"), error instanceof Error ? error.message : String(error));
+    Logger_default.error(error);
+    process.exit(1);
+  }
+};
+var defaultName = (file) => {
+  const base = import_path32.default.basename(file, import_path32.default.extname(file)).toLowerCase().replace(/[^a-z0-9]+/g, "_");
+  const trimmed = base.replace(/^_+|_+$/g, "") || "copybook";
+  return trimmed.startsWith("p_") ? trimmed : `p_${trimmed}`;
+};
+
 // src/index.ts
 init_src3();
 init_src5();
 
 // src/actions/automap.ts
-var import_chalk14 = __toESM(require("chalk"));
+var import_chalk16 = __toESM(require("chalk"));
 var import_ora5 = __toESM(require("ora"));
 init_src10();
-var import_fs31 = __toESM(require("fs"));
-var import_path32 = __toESM(require("path"));
+var import_fs33 = __toESM(require("fs"));
+var import_path33 = __toESM(require("path"));
 init_src4();
 init_src10();
 init_src2();
 var automap = async (producerName, schemaNames) => {
   try {
     compile();
-    const spinner = (0, import_ora5.default)(import_chalk14.default.blue("Auto-mapping producer data...\n")).start();
+    const spinner = (0, import_ora5.default)(import_chalk16.default.blue("Auto-mapping producer data...\n")).start();
     const producer = Environment_default.getProducer(producerName);
     if (!producer) {
       throw new Error(`Producer ${producerName} not found`);
@@ -60428,24 +61510,24 @@ var automap = async (producerName, schemaNames) => {
     const mapResult = await AutoMapperEngine_default.map(sampleStrings, schemas, producer.settings.fileKey, [source]);
     for (const producer2 of mapResult.producers) {
       const producerPath = Environment_default.resolveResourceFilePath("producers", producer2.name);
-      import_fs31.default.mkdirSync(import_path32.default.dirname(producerPath), { recursive: true });
-      import_fs31.default.writeFileSync(producerPath, JSON.stringify(producer2, null, 4));
-      console.log(import_chalk14.default.blue(`Created producer: ${producer2.name}`));
+      import_fs33.default.mkdirSync(import_path33.default.dirname(producerPath), { recursive: true });
+      import_fs33.default.writeFileSync(producerPath, JSON.stringify(producer2, null, 4));
+      console.log(import_chalk16.default.blue(`Created producer: ${producer2.name}`));
     }
     for (const consumer of mapResult.consumers) {
       const consumerPath = Environment_default.resolveResourceFilePath("consumers", consumer.name);
-      import_fs31.default.mkdirSync(import_path32.default.dirname(consumerPath), { recursive: true });
-      import_fs31.default.writeFileSync(consumerPath, JSON.stringify(consumer, null, 4));
-      console.log(import_chalk14.default.blue(`Created consumer: ${consumer.name}`));
+      import_fs33.default.mkdirSync(import_path33.default.dirname(consumerPath), { recursive: true });
+      import_fs33.default.writeFileSync(consumerPath, JSON.stringify(consumer, null, 4));
+      console.log(import_chalk16.default.blue(`Created consumer: ${consumer.name}`));
     }
     spinner.succeed("Producer has been successfully mapped");
-    console.log(import_chalk14.default.green(`
+    console.log(import_chalk16.default.green(`
 \u2705 Created ${mapResult.producers.length} producers!`));
-    console.log(import_chalk14.default.green(`\u2705 Created ${mapResult.consumers.length} consumers!`));
+    console.log(import_chalk16.default.green(`\u2705 Created ${mapResult.consumers.length} consumers!`));
     await Logger_default.flush();
     process.exit(0);
   } catch (err2) {
-    console.error(import_chalk14.default.red.bold("\n\u274C Unexpected error during automapping:"), err2 instanceof Error ? err2.message : String(err2));
+    console.error(import_chalk16.default.red.bold("\n\u274C Unexpected error during automapping:"), err2 instanceof Error ? err2.message : String(err2));
     Logger_default.error(err2);
     await Logger_default.flush();
     process.exit(1);
@@ -60453,7 +61535,7 @@ var automap = async (producerName, schemaNames) => {
 };
 
 // src/actions/sample.ts
-var import_chalk15 = __toESM(require("chalk"));
+var import_chalk17 = __toESM(require("chalk"));
 var import_ora6 = __toESM(require("ora"));
 init_src5();
 init_src2();
@@ -60461,23 +61543,23 @@ var sample = async (resourceName, sampleSize = 10) => {
   try {
     compile();
     console.log();
-    const spinner = (0, import_ora6.default)(import_chalk15.default.blue(`Sampling "${resourceName}"...`)).start();
+    const spinner = (0, import_ora6.default)(import_chalk17.default.blue(`Sampling "${resourceName}"...`)).start();
     const { kind, records, note } = await SampleRunner_default.read(resourceName, sampleSize);
-    spinner.succeed(import_chalk15.default.green(`Sample data retrieved from ${kind} "${resourceName}"`));
-    console.log(import_chalk15.default.gray(`   ${note}`));
+    spinner.succeed(import_chalk17.default.green(`Sample data retrieved from ${kind} "${resourceName}"`));
+    console.log(import_chalk17.default.gray(`   ${note}`));
     if (records.length === 0) {
-      console.log(import_chalk15.default.yellow("No data found in the dataset."));
+      console.log(import_chalk17.default.yellow("No data found in the dataset."));
       return;
     }
-    console.log(import_chalk15.default.cyan(`
+    console.log(import_chalk17.default.cyan(`
 \u{1F4CA} Sample Data (showing ${records.length} rows):`));
-    console.log(import_chalk15.default.gray("\u2500".repeat(80)));
+    console.log(import_chalk17.default.gray("\u2500".repeat(80)));
     displayDataAsTable(records);
-    console.log(import_chalk15.default.gray("\u2500".repeat(80)));
-    console.log(import_chalk15.default.green(`\u2705 Successfully sampled ${records.length} rows from ${kind} "${resourceName}"`));
+    console.log(import_chalk17.default.gray("\u2500".repeat(80)));
+    console.log(import_chalk17.default.green(`\u2705 Successfully sampled ${records.length} rows from ${kind} "${resourceName}"`));
   } catch (err2) {
     const myErr = Helper_default.asError(err2);
-    console.error(import_chalk15.default.red.bold("\n\u274C Error during sampling:"), myErr.message);
+    console.error(import_chalk17.default.red.bold("\n\u274C Error during sampling:"), myErr.message);
     Logger_default.error(err2);
     await Logger_default.flush();
     process.exit(1);
@@ -60506,7 +61588,7 @@ var displayDataAsTable = (data) => {
     columnWidths[field] = Math.min(columnWidths[field], maxColumnWidth);
   });
   const headerRow = fields.map(
-    (field) => import_chalk15.default.bold(field.padEnd(columnWidths[field]))
+    (field) => import_chalk17.default.bold(field.padEnd(columnWidths[field]))
   ).join(" \u2502 ");
   console.log("\u2502 " + headerRow + " \u2502");
   const separator = fields.map(
@@ -60521,33 +61603,35 @@ var displayDataAsTable = (data) => {
       return truncatedValue.padEnd(columnWidths[field]);
     }).join(" \u2502 ");
     if (index % 2 === 0) {
-      console.log("\u2502 " + import_chalk15.default.white(dataRow) + " \u2502");
+      console.log("\u2502 " + import_chalk17.default.white(dataRow) + " \u2502");
     } else {
-      console.log("\u2502 " + import_chalk15.default.gray(dataRow) + " \u2502");
+      console.log("\u2502 " + import_chalk17.default.gray(dataRow) + " \u2502");
     }
   });
 };
 var formatValue = (value) => {
   if (value === null || value === void 0) {
-    return import_chalk15.default.dim("null");
+    return import_chalk17.default.dim("null");
   }
   if (typeof value === "string") {
     return value;
   }
   if (typeof value === "number") {
-    return import_chalk15.default.cyan(value.toString());
+    return import_chalk17.default.cyan(value.toString());
   }
   if (typeof value === "boolean") {
-    return import_chalk15.default.yellow(value.toString());
+    return import_chalk17.default.yellow(value.toString());
   }
   if (value instanceof Date) {
-    return import_chalk15.default.magenta(value.toISOString());
+    return import_chalk17.default.magenta(value.toISOString());
   }
-  return import_chalk15.default.dim(JSON.stringify(value));
+  return import_chalk17.default.dim(JSON.stringify(value));
 };
 
 // src/actions/synth.ts
-var import_chalk16 = __toESM(require("chalk"));
+var import_path34 = __toESM(require("path"));
+var import_chalk18 = __toESM(require("chalk"));
+init_src3();
 init_src4();
 init_src5();
 init_src10();
@@ -60558,19 +61642,21 @@ var synth = async (consumerName, args) => {
     compile();
     assertLicence();
     const consumers = resolveConsumers(consumerName, args.project);
+    const outputPath = import_path34.default.resolve(args.output ?? import_path34.default.join(Constants_default.defaults.REMORA_PATH, Constants_default.defaults.SYNTH_OUTPUT_FOLDER));
     console.log();
-    console.log(import_chalk16.default.blue(`Synthesizing ${consumers.length === 1 ? `consumer ${consumers[0].name}` : `${consumers.length} consumers`} with ${args.records} input records/producer (seed "${args.seed}")...
+    console.log(import_chalk18.default.blue(`Synthesizing ${consumers.length === 1 ? `consumer ${consumers[0].name}` : `${consumers.length} consumers`} with ${args.records} input records/producer (seed "${args.seed}")...`));
+    console.log(import_chalk18.default.gray(`Exports are written to ${outputPath}, not to the consumers' configured destinations.
 `));
     bundle = await SyntheticInputEngine_default.generate(Environment_default.getAllProducers(), { records: args.records, seed: args.seed }, Environment_default.getAllCodeSets());
     const results = [];
     for (const consumer of consumers)
-      results.push(await runConsumer(consumer, bundle));
+      results.push(await runConsumer(consumer, bundle, outputPath));
     report3(results);
     await Logger_default.flush();
     process.exit(results.some((x2) => !x2.success) ? 1 : 0);
   } catch (err2) {
     const myErr = Helper_default.asError(err2);
-    console.error(import_chalk16.default.red.bold("\n\u274C Unexpected error during synthetic run:"), myErr.message);
+    console.error(import_chalk18.default.red.bold("\n\u274C Unexpected error during synthetic run:"), myErr.message);
     Logger_default.error(myErr);
     await Logger_default.flush();
     process.exit(1);
@@ -60593,13 +61679,14 @@ var resolveConsumers = (consumerName, project) => {
   if (all.length === 0) throw new Error("No consumers found in the project.");
   return all;
 };
-var runConsumer = async (consumer, bundle) => {
+var runConsumer = async (consumer, bundle, exportPath) => {
   try {
-    const check2 = LicenceManager_default.validate(ProcessENVManager_default.getEnvVariable("REMORA_LICENCE_KEY"));
+    const check = assertLicence();
     const response = await ExecutorOrchestrator_default.launch({
       consumer,
-      details: { invokedBy: "CLI", user: { _id: check2.customer, name: check2.customer, type: "licence" } },
+      details: { invokedBy: "CLI", user: { _id: check.customer, name: check.customer, type: "licence" } },
       syntheticProducerInputs: bundle.inputs,
+      syntheticExportPath: exportPath,
       logProgress: true
     });
     return { consumer, success: true, outputCount: response.outputCount, resultUri: response.resultUri, elapsedMS: response.elapsedMS };
@@ -60609,25 +61696,18 @@ var runConsumer = async (consumer, bundle) => {
     return { consumer, success: false, error: myErr.message };
   }
 };
-var assertLicence = () => {
-  const check2 = LicenceManager_default.validate(ProcessENVManager_default.getEnvVariable("REMORA_LICENCE_KEY"));
-  if (!check2.valid) {
-    console.error(import_chalk16.default.red('Invalid Remora licence key, the product is not active: remember to set "REMORA_LICENCE_KEY" environment variable.'));
-    process.exit(1);
-  }
-};
 var report3 = (results) => {
-  console.log(import_chalk16.default.green("\n\u2705 Synthetic run complete!\n"));
+  console.log(import_chalk18.default.green("\n\u2705 Synthetic run complete!\n"));
   for (const result of results) {
     if (!result.success) {
-      console.log(import_chalk16.default.red(`  \u2717 ${result.consumer.name} \u2014 ${result.error}`));
+      console.log(import_chalk18.default.red(`  \u2717 ${result.consumer.name} \u2014 ${result.error}`));
       continue;
     }
-    const info = import_chalk16.default.gray(` (${result.outputCount} rows, ${Helper_default.formatDuration(result.elapsedMS ?? 0)})`);
+    const info = import_chalk18.default.gray(` (${result.outputCount} rows, ${Helper_default.formatDuration(result.elapsedMS ?? 0)})`);
     if (result.resultUri)
-      console.log(import_chalk16.default.green(`  \u2022 ${result.consumer.name} \u2192 ${result.resultUri}`) + info);
+      console.log(import_chalk18.default.green(`  \u2022 ${result.consumer.name} \u2192 ${result.resultUri}`) + info);
     else
-      console.log(import_chalk16.default.green(`  \u2022 ${result.consumer.name}`) + info);
+      console.log(import_chalk18.default.green(`  \u2022 ${result.consumer.name}`) + info);
   }
 };
 
@@ -60646,12 +61726,11 @@ if (!process.env.REMORA_RUNTIME_CONTEXT) {
 }
 ProcessShutdownManager_default.init("Remora CLI");
 var program = new import_commander.Command();
-var remoraLicenceKey = ProcessENVManager_default.getEnvVariable("REMORA_LICENCE_KEY");
-var check = LicenceManager_default.validate(remoraLicenceKey);
-if (!check.valid) {
-  console.error(`Invalid Remora licence key, the product is not active: remember to set "REMORA_LICENCE_KEY" environment variable.`);
-  process.exit(1);
-}
+var LICENCE_EXEMPT_COMMANDS = ["init", "version"];
+program.hook("preAction", (_root, command5) => {
+  if (LICENCE_EXEMPT_COMMANDS.includes(command5.name())) return;
+  assertLicence();
+});
 var { heapSizeMB } = Runtime_default.getHeap();
 if (heapSizeMB < Constants_default.defaults.MIN_RUNTIME_HEAP_MB)
   console.warn(`Remora is running with ${heapSizeMB}MB of runtime heap, which is below the bare minimum of ${Constants_default.defaults.MIN_RUNTIME_HEAP_MB}MB (Recommended: ${Constants_default.defaults.RECOMMENDED_RUNTIME_HEAP_MB}MB).`);
@@ -60672,6 +61751,7 @@ program.command("discover").description("Discover the data shape of a producer a
 program.command("graph").description("Print the project lineage (what feeds what) to stdout as a diagram or as JSON").option("-f, --format <format>", "Output format: mermaid, dot or json", "mermaid").action((options2) => graph(options2));
 program.command("ui-preview").description("Open a visual preview of the project: the lineage graph, and a table inspector for every resource").option("-p, --port <number>", "Port to serve the preview on (default: 5070, or the next free one)").option("--no-open", "Do not open a browser window").action((options2) => ui_preview(options2));
 program.command("create-producer <name>").description("Create a new producer configuration with default settings").action(create_producer);
+program.command("import-copybook <file>").description("Read a COBOL copybook and write the FIXED producer for the record it describes, computing every position from the PIC widths").option("-n, --name <name>", 'Name of the producer to write (default: the copybook file name, prefixed with "p_")').action((file, options2) => import_copybook(file, options2));
 program.command("automap").description("Automatically map a producer to consumers using specified schemas.").argument("<producer>", "The producer to analyze").argument("<schemas...>", "One or more schema names to map against").action(automap);
 program.command("create-consumer <name>").description("Create a new consumer configuration with default settings").option("-p, --producer <name>", "Producer to create a one-to-one mapping from").action((name, options2) => create_consumer(name, options2.producer));
 program.command("sample <name>").description("Sample data from a producer or consumer and display it in a formatted table").option("-s, --size <number>", "Number of sample rows to display (default: 10)", "10").action((name, options2) => {
@@ -60682,13 +61762,13 @@ program.command("sample <name>").description("Sample data from a producer or con
   }
   sample(name, sampleSize);
 });
-program.command("synth [consumer]").description("Run the full pipeline on synthetic data: generate fake producer input, then execute one consumer, all consumers of a project (--project), or all consumers, exporting to their real destinations").option("-r, --records <number>", "Number of synthetic INPUT records to generate per producer", "100").option("-s, --seed <string>", "Seed for deterministic generation (same seed => same data)", "remora").option("-p, --project <name>", "Run all consumers belonging to the specified project").action((consumer, options2) => {
+program.command("synth [consumer]").description("Run the full pipeline on synthetic data: generate fake producer input, then execute one consumer, all consumers of a project (--project), or all consumers, writing the exports to a local folder instead of their configured destinations").option("-r, --records <number>", "Number of synthetic INPUT records to generate per producer", "100").option("-s, --seed <string>", "Seed for deterministic generation (same seed => same data)", "remora").option("-p, --project <name>", "Run all consumers belonging to the specified project").option("-o, --output <dir>", `Folder to write the exports into, one subfolder per consumer (default: ${Constants_default.defaults.REMORA_PATH}/${Constants_default.defaults.SYNTH_OUTPUT_FOLDER})`).action((consumer, options2) => {
   const records = parseInt(options2.records, 10);
   if (isNaN(records) || records <= 0) {
     console.error("Record count must be a positive number");
     process.exit(1);
   }
-  synth(consumer, { records, seed: options2.seed, project: options2.project });
+  synth(consumer, { records, seed: options2.seed, project: options2.project, output: options2.output });
 });
 program.parse(process.argv);
 /*! Bundled license information: