@forzalabs/remora 2.6.0 → 2.7.0

package/workers/ExecutorWorker.js

@@ -8538,7 +8538,7 @@ var require_node2 = __commonJS({
 var require_tail_file = __commonJS({
   "../../node_modules/winston/lib/winston/tail-file.js"(exports2, module2) {
     "use strict";
-    var fs33 = require("fs");
+    var fs34 = require("fs");
     var { StringDecoder } = require("string_decoder");
     var { Stream } = require_readable();
     function noop() {
@@ -8559,7 +8559,7 @@ var require_tail_file = __commonJS({
         stream.emit("end");
         stream.emit("close");
       };
-      fs33.open(options2.file, "a+", "0644", (err2, fd) => {
+      fs34.open(options2.file, "a+", "0644", (err2, fd) => {
         if (err2) {
           if (!iter) {
             stream.emit("error", err2);
@@ -8571,10 +8571,10 @@ var require_tail_file = __commonJS({
         }
         (function read() {
           if (stream.destroyed) {
-            fs33.close(fd, noop);
+            fs34.close(fd, noop);
             return;
           }
-          return fs33.read(fd, buffer, 0, buffer.length, pos, (error, bytes) => {
+          return fs34.read(fd, buffer, 0, buffer.length, pos, (error, bytes) => {
             if (error) {
               if (!iter) {
                 stream.emit("error", error);
@@ -8633,7 +8633,7 @@ var require_tail_file = __commonJS({
 var require_file = __commonJS({
   "../../node_modules/winston/lib/winston/transports/file.js"(exports2, module2) {
     "use strict";
-    var fs33 = require("fs");
+    var fs34 = require("fs");
     var path22 = require("path");
     var asyncSeries = require_series();
     var zlib3 = require("zlib");
@@ -8838,7 +8838,7 @@ var require_file = __commonJS({
         let buff = "";
         let results = [];
         let row = 0;
-        const stream = fs33.createReadStream(file, {
+        const stream = fs34.createReadStream(file, {
           encoding: "utf8"
         });
         stream.on("error", (err2) => {
@@ -8990,7 +8990,7 @@ var require_file = __commonJS({
       stat(callback) {
         const target = this._getFile();
         const fullpath = path22.join(this.dirname, target);
-        fs33.stat(fullpath, (err2, stat) => {
+        fs34.stat(fullpath, (err2, stat) => {
           if (err2 && err2.code === "ENOENT") {
             debug("ENOENT\xA0ok", fullpath);
             this.filename = target;
@@ -9095,7 +9095,7 @@ var require_file = __commonJS({
       _createStream(source) {
         const fullpath = path22.join(this.dirname, this.filename);
         debug("create stream start", fullpath, this.options);
-        const dest = fs33.createWriteStream(fullpath, this.options).on("error", (err2) => debug(err2)).on("close", () => debug("close", dest.path, dest.bytesWritten)).on("open", () => {
+        const dest = fs34.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);
@@ -9174,7 +9174,7 @@ var require_file = __commonJS({
         const isZipped = this.zippedArchive ? ".gz" : "";
         const filePath = `${basename}${isOldest}${ext}${isZipped}`;
         const target = path22.join(this.dirname, filePath);
-        fs33.unlink(target, callback);
+        fs34.unlink(target, callback);
       }
       /**
        * Roll files forward based on integer, up to maxFiles. e.g. if base if
@@ -9197,17 +9197,17 @@ var require_file = __commonJS({
           tasks.push(function(i6, cb) {
             let fileName = `${basename}${i6 - 1}${ext}${isZipped}`;
             const tmppath = path22.join(this.dirname, fileName);
-            fs33.exists(tmppath, (exists) => {
+            fs34.exists(tmppath, (exists) => {
               if (!exists) {
                 return cb(null);
               }
               fileName = `${basename}${i6}${ext}${isZipped}`;
-              fs33.rename(tmppath, path22.join(this.dirname, fileName), cb);
+              fs34.rename(tmppath, path22.join(this.dirname, fileName), cb);
             });
           }.bind(this, x2));
         }
         asyncSeries(tasks, () => {
-          fs33.rename(
+          fs34.rename(
             path22.join(this.dirname, `${basename}${ext}${isZipped}`),
             path22.join(this.dirname, `${basename}1${ext}${isZipped}`),
             callback
@@ -9223,22 +9223,22 @@ var require_file = __commonJS({
        * @private
        */
       _compressFile(src, dest, callback) {
-        fs33.access(src, fs33.F_OK, (err2) => {
+        fs34.access(src, fs34.F_OK, (err2) => {
           if (err2) {
             return callback();
           }
           var gzip = zlib3.createGzip();
-          var inp = fs33.createReadStream(src);
-          var out = fs33.createWriteStream(dest);
+          var inp = fs34.createReadStream(src);
+          var out = fs34.createWriteStream(dest);
           out.on("finish", () => {
-            fs33.unlink(src, callback);
+            fs34.unlink(src, callback);
           });
           inp.pipe(gzip).pipe(out);
         });
       }
       _createLogDirIfNotExist(dirPath) {
-        if (!fs33.existsSync(dirPath)) {
-          fs33.mkdirSync(dirPath, { recursive: true });
+        if (!fs34.existsSync(dirPath)) {
+          fs34.mkdirSync(dirPath, { recursive: true });
         }
       }
     };
@@ -11809,7 +11809,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,
@@ -11846,6 +11846,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
@@ -11937,7 +11944,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,
@@ -12228,7 +12235,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"}.`);
@@ -12741,7 +12748,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();
@@ -12751,6 +12758,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) => {
@@ -12852,6 +12866,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) {
@@ -12875,6 +12892,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`
@@ -13510,7 +13588,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();
@@ -13523,8 +13601,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() {
@@ -13603,22 +13683,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.`);
@@ -13631,16 +13714,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)
@@ -13753,9 +13859,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;
@@ -13798,6 +13904,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)
@@ -13906,16 +14026,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;
         };
@@ -13925,7 +14041,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`,
@@ -13933,14 +14048,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)
@@ -13975,8 +14117,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));
@@ -34011,12 +34154,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,
@@ -34024,6 +34262,8 @@ var init_FixedWidthWriter = __esm({
       datetime: BASE_FILL,
       boolean: BASE_FILL
     };
+    MAX_SCALE2 = 15;
+    SIGN_MODES3 = ["overpunch", "leading", "trailing"];
     FixedWidthWriterClass = class {
       constructor() {
         /**
@@ -34204,6 +34444,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(column, 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 = (column, 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 && column.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 "${column.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;
         };
         /**
@@ -34229,7 +34487,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. */
@@ -34270,11 +34530,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
@@ -34283,14 +34565,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
@@ -34298,7 +34583,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) => {
@@ -34370,7 +34655,7 @@ var require_pend = __commonJS({
 // ../../node_modules/yauzl/fd-slicer.js
 var require_fd_slicer = __commonJS({
   "../../node_modules/yauzl/fd-slicer.js"(exports2) {
-    var fs33 = require("fs");
+    var fs34 = require("fs");
     var util = require("util");
     var stream = require("stream");
     var Readable10 = stream.Readable;
@@ -34390,7 +34675,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self2 = this;
       self2.pend.go(function(cb) {
-        fs33.read(self2.fd, buffer, offset, length, position, function(err2, bytesRead, buffer2) {
+        fs34.read(self2.fd, buffer, offset, length, position, function(err2, bytesRead, buffer2) {
           cb();
           callback(err2, bytesRead, buffer2);
         });
@@ -34407,7 +34692,7 @@ var require_fd_slicer = __commonJS({
       self2.refCount -= 1;
       if (self2.refCount < 0) throw new Error("invalid unref");
       if (self2.refCount > 0) return;
-      fs33.close(self2.fd, onCloseDone);
+      fs34.close(self2.fd, onCloseDone);
       function onCloseDone(err2) {
         if (err2) {
           self2.emit("error", err2);
@@ -34439,7 +34724,7 @@ var require_fd_slicer = __commonJS({
       }
       self2.context.pend.go(function(cb) {
         var buffer = Buffer.allocUnsafe(toRead);
-        fs33.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err2, bytesRead) {
+        fs34.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err2, bytesRead) {
           if (err2) {
             self2.destroy(err2);
           } else if (bytesRead === 0) {
@@ -34799,7 +35084,7 @@ var require_crc32 = __commonJS({
 // ../../node_modules/yauzl/index.js
 var require_yauzl = __commonJS({
   "../../node_modules/yauzl/index.js"(exports2) {
-    var fs33 = require("fs");
+    var fs34 = require("fs");
     var zlib3 = require("zlib");
     var fd_slicer = require_fd_slicer();
     var util = require("util");
@@ -34868,10 +35153,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs33.open(path22, "r", function(err2, fd) {
+      fs34.open(path22, "r", function(err2, fd) {
         if (err2) return callback(err2);
         fromFd(fd, options2, function(err3, zipfile) {
-          if (err3) fs33.close(fd, defaultCallback);
+          if (err3) fs34.close(fd, defaultCallback);
           callback(err3, zipfile);
         });
       });
@@ -34888,7 +35173,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs33.fstat(fd, function(err2, stats) {
+      fs34.fstat(fd, function(err2, stats) {
         if (err2) return callback(err2);
         var reader = new fd_slicer.FdSlicer(fd);
         fromRandomAccessReader(reader, stats.size, options2, callback);
@@ -38970,6 +39255,7 @@ var init_src5 = __esm({
     init_DatasetCodec();
     init_FixedWidthParser();
     init_FixedWidthWriter();
+    init_NumericCodec();
     init_ParseCompression();
     init_ParseHelper();
     init_XLSParser();
@@ -46858,6 +47144,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 {
@@ -46869,6 +47165,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
@@ -46886,6 +47183,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)
@@ -48021,6 +48319,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_src5();
     import_dayjs = __toESM(require("dayjs"), 1);
     import_customParseFormat = __toESM(require("dayjs/plugin/customParseFormat"), 1);
     import_utc = __toESM(require("dayjs/plugin/utc"), 1);
@@ -48062,6 +48361,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`. */
@@ -51470,7 +51770,10 @@ var init_SyntheticInputEngine = __esm({
             name,
             type: dim.type ?? "string",
             format: dim.format,
-            decimals: synth.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: synth.decimals ?? dim.scale,
             min,
             max,
             isPk: dim.pk === true,
@@ -51632,6 +51935,650 @@ 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;
+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();
+  }
+});
+
+// ../../packages/engines/src/copybook/CopybookEmitter.ts
+var DEFAULT_SOURCE, REPEATED_FIELD_NAMING, CopybookEmitterClass, CopybookEmitter;
+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();
+  }
+});
+
 // ../../packages/engines/src/consumer/ConsumerManager.ts
 var ConsumerManagerClass, ConsumerManager, ConsumerManager_default;
 var init_ConsumerManager = __esm({
@@ -51795,21 +52742,21 @@ var init_ConsumerOnFinishManager = __esm({
     init_src2();
     ConsumerOnFinishManagerClass = class {
       constructor() {
-        this.onConsumerSuccess = async (consumer, executionId, runConsumer) => {
+        this.onConsumerSuccess = async (consumer, executionId, runConsumer, options2) => {
           void executionId;
           for (const output of consumer.outputs) {
             if (output.onSuccess)
-              await this.performOnSuccessActions(consumer, output, runConsumer);
+              await this.performOnSuccessActions(consumer, output, runConsumer, options2);
           }
         };
-        this.onConsumerError = async (consumer, executionId, runConsumer) => {
+        this.onConsumerError = async (consumer, executionId, runConsumer, options2) => {
           void executionId;
           for (const output of consumer.outputs) {
             if (output.onError)
-              await this.performOnErrorActions(consumer, output, runConsumer);
+              await this.performOnErrorActions(consumer, output, runConsumer, options2);
           }
         };
-        this.performOnSuccessActions = async (consumer, output, runConsumer) => {
+        this.performOnSuccessActions = async (consumer, output, runConsumer, options2) => {
           Affirm_default(consumer, "Invalid consumer");
           Affirm_default(output, "Invalid output");
           if (!output.onSuccess || output.onSuccess.length === 0)
@@ -51817,6 +52764,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;
               }
@@ -51829,6 +52778,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
@@ -51947,7 +52902,7 @@ var init_ConsumerOnFinishManager = __esm({
           await destinationDriver.copyFromS3(sourceSource.authentication["bucket"], fileKey, fileKey);
           await sourceDriver.deleteFile(fileKey);
         };
-        this.performOnErrorActions = async (consumer, output, runConsumer) => {
+        this.performOnErrorActions = async (consumer, output, runConsumer, options2) => {
           Affirm_default(consumer, "Invalid consumer");
           Affirm_default(output, "Invalid output");
           if (!output.onError || output.onError.length === 0)
@@ -51955,6 +52910,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;
               }
@@ -56422,6 +57379,8 @@ var init_src10 = __esm({
     init_DeveloperEngine();
     init_LLM();
     init_SyntheticInputEngine();
+    init_CopybookParser();
+    init_CopybookEmitter();
     init_ConsumerManager();
     init_ConsumerOnFinishManager();
     init_RequestExecutor();
@@ -56533,9 +57492,10 @@ var init_DatasetSchema = __esm({
           return dsSchema.columns.map((column) => column.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))
@@ -56662,9 +57622,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();
@@ -56752,17 +57713,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;
@@ -56925,6 +57886,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(/\.[^.]+$/, "");
@@ -56942,11 +57922,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();
@@ -56963,10 +57943,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
@@ -57094,8 +58074,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;
@@ -57186,9 +58166,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();
@@ -57218,7 +58198,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;
@@ -57238,7 +58218,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"))
@@ -57275,7 +58255,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] ?? "");
@@ -57292,7 +58272,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("|");
@@ -57316,7 +58296,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()) {
@@ -57407,7 +58387,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) {
@@ -57554,10 +58534,10 @@ var init_ExecutorPerformance = __esm({
 });
 
 // ../../packages/executors/src/ExecutorWriter.ts
-var fs28, ExecutorWriter, ExecutorWriter_default;
+var fs29, ExecutorWriter, ExecutorWriter_default;
 var init_ExecutorWriter = __esm({
   "../../packages/executors/src/ExecutorWriter.ts"() {
-    fs28 = __toESM(require("fs"));
+    fs29 = __toESM(require("fs"));
     init_src();
     init_src3();
     init_src10();
@@ -57609,7 +58589,7 @@ var init_ExecutorWriter = __esm({
           await this._route(pass, dsSchema);
           if (pass.buckets.size === 0)
             return [{ path: sourcePath, label: this.UNSPLIT_LABEL }];
-          await fs28.promises.unlink(sourcePath);
+          await fs29.promises.unlink(sourcePath);
           return this._listFiles(pass);
         };
         /**
@@ -57617,7 +58597,7 @@ var init_ExecutorWriter = __esm({
          */
         this._route = async (pass, dsSchema) => {
           const parseLine = pass.keys.length === 0 ? null : LineParser_default.datasetParser(dsSchema);
-          const readStream = fs28.createReadStream(pass.sourcePath);
+          const readStream = fs29.createReadStream(pass.sourcePath);
           try {
             for await (const line of readLines(readStream)) {
               const bucket = this._bucketFor(line, pass, parseLine);
@@ -57721,7 +58701,7 @@ var init_ExecutorWriter = __esm({
           }
           if (pass.openStreams.length >= Constants_default.defaults.MAX_OPEN_SPLIT_STREAMS)
             await this._closeStream(pass.openStreams.shift());
-          bucket.stream = fs28.createWriteStream(this.getCompletedPath(pass.sourcePath, this._composeLabel(bucket, pass)), { flags: "a" });
+          bucket.stream = fs29.createWriteStream(this.getCompletedPath(pass.sourcePath, this._composeLabel(bucket, pass)), { flags: "a" });
           pass.openStreams.push(bucket);
           return bucket.stream;
         };
@@ -57999,10 +58979,10 @@ var init_OrchestratorHelper = __esm({
 });
 
 // ../../packages/executors/src/LookupResolver.ts
-var import_fs23, import_promises17, import_path22, LookupResolverClass, LookupResolver, LookupResolver_default;
+var import_fs24, import_promises17, import_path22, LookupResolverClass, LookupResolver, LookupResolver_default;
 var init_LookupResolver = __esm({
   "../../packages/executors/src/LookupResolver.ts"() {
-    import_fs23 = __toESM(require("fs"));
+    import_fs24 = __toESM(require("fs"));
     import_promises17 = __toESM(require("fs/promises"));
     import_path22 = __toESM(require("path"));
     init_src();
@@ -58080,7 +59060,7 @@ var init_LookupResolver = __esm({
           const dict = {};
           let rowsRead = 0;
           let warnedDup = false;
-          for await (const line of readLines(import_fs23.default.createReadStream(capture.path))) {
+          for await (const line of readLines(import_fs24.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})`);
@@ -58119,10 +59099,10 @@ var init_LookupResolver = __esm({
 });
 
 // ../../packages/executors/src/ConsumerInputResolver.ts
-var import_fs24, import_promises18, import_path23, ConsumerInputResolverClass, ConsumerInputResolver, ConsumerInputResolver_default;
+var import_fs25, import_promises18, import_path23, ConsumerInputResolverClass, ConsumerInputResolver, ConsumerInputResolver_default;
 var init_ConsumerInputResolver = __esm({
   "../../packages/executors/src/ConsumerInputResolver.ts"() {
-    import_fs24 = __toESM(require("fs"));
+    import_fs25 = __toESM(require("fs"));
     import_promises18 = __toESM(require("fs/promises"));
     import_path23 = __toESM(require("path"));
     init_src();
@@ -58146,7 +59126,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_fs24.default.existsSync(cached.path)) {
+            if (!cached || !import_fs25.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}"`);
@@ -58225,10 +59205,10 @@ var ExecutorOrchestrator_exports = {};
 __export(ExecutorOrchestrator_exports, {
   default: () => ExecutorOrchestrator_default
 });
-var import_fs25, import_promises19, import_path24, import_workerpool, import_promises20, ExecutorOrchestratorClass, ExecutorOrchestrator, ExecutorOrchestrator_default;
+var import_fs26, import_promises19, import_path24, import_workerpool, import_promises20, ExecutorOrchestratorClass, ExecutorOrchestrator, ExecutorOrchestrator_default;
 var init_ExecutorOrchestrator = __esm({
   "../../packages/executors/src/ExecutorOrchestrator.ts"() {
-    import_fs25 = __toESM(require("fs"));
+    import_fs26 = __toESM(require("fs"));
     import_promises19 = __toESM(require("fs/promises"));
     import_path24 = __toESM(require("path"));
     import_workerpool = __toESM(require("workerpool"));
@@ -58417,15 +59397,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`);
             }
@@ -58444,7 +59426,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);
@@ -58465,7 +59447,7 @@ var init_ExecutorOrchestrator = __esm({
               Logger_default.info(`[${usageId}] Producer "${prod.name}": source returned no files, skipping`);
               continue;
             }
-            if (!import_fs25.default.existsSync(response.files[0].fullUri)) {
+            if (!import_fs26.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`);
@@ -58620,7 +59602,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
             });
           };
         };
@@ -58630,7 +59613,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_fs25.default.statSync(fileUri).size;
+          const fileSize = import_fs26.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 }];
@@ -58640,7 +59623,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_fs25.default.openSync(fileUri, "r");
+          const fd = import_fs26.default.openSync(fileUri, "r");
           try {
             const offsets = [];
             let currentStart = 0;
@@ -58658,7 +59641,7 @@ var init_ExecutorOrchestrator = __esm({
             }
             return offsets;
           } finally {
-            import_fs25.default.closeSync(fd);
+            import_fs26.default.closeSync(fd);
           }
         };
         /**
@@ -58726,7 +59709,7 @@ var init_ExecutorOrchestrator = __esm({
           let currentPos = position;
           while (currentPos < fileSize) {
             const bytesToRead = Math.min(BUFFER_SIZE, fileSize - currentPos);
-            const bytesRead = import_fs25.default.readSync(fd, buffer, 0, bytesToRead, currentPos);
+            const bytesRead = import_fs26.default.readSync(fd, buffer, 0, bytesToRead, currentPos);
             if (bytesRead === 0) break;
             for (let i6 = 0; i6 < bytesRead; i6++) {
               if (buffer[i6] === 10) {
@@ -58751,9 +59734,9 @@ var init_ExecutorOrchestrator = __esm({
             return;
           }
           const parseLine = LineParser_default.datasetParser(dsSchema);
-          const output = import_fs25.default.createWriteStream(targetPath);
+          const output = import_fs26.default.createWriteStream(targetPath);
           try {
-            for await (const line of readLines(import_fs25.default.createReadStream(sourcePath))) {
+            for await (const line of readLines(import_fs26.default.createReadStream(sourcePath))) {
               if (!line.length) continue;
               const record = parseLine(line);
               if (!output.write(JSON.stringify(record) + "\n"))
@@ -58851,7 +59834,7 @@ var init_ExecutorOrchestrator = __esm({
                 });
                 await (0, import_promises20.pipeline)(
                   xlsCsvStream,
-                  import_fs25.default.createWriteStream(decodedPath)
+                  import_fs26.default.createWriteStream(decodedPath)
                 );
                 const fileStats = await import_promises19.default.stat(decodedPath);
                 decodedFiles.push({ fullUri: decodedPath, fileSize: fileStats.size });
@@ -58911,8 +59894,8 @@ var init_ExecutorOrchestrator = __esm({
             const perf = performance.now();
             for (const workerResult of executorResults) {
               await (0, import_promises20.pipeline)(
-                import_fs25.default.createReadStream(workerResult.resultUri),
-                import_fs25.default.createWriteStream(mainPath, { flags: "a" })
+                import_fs26.default.createReadStream(workerResult.resultUri),
+                import_fs26.default.createWriteStream(mainPath, { flags: "a" })
               );
               await import_promises19.default.unlink(workerResult.resultUri);
             }
@@ -58994,7 +59977,7 @@ init_ConsumerExecutor();
 init_DatasetSchema();
 
 // ../../packages/executors/src/Executor.ts
-var import_fs22 = __toESM(require("fs"));
+var import_fs23 = __toESM(require("fs"));
 init_ProducerExecutor();
 init_ConsumerExecutor();
 
@@ -59288,18 +60271,18 @@ var Executor = class {
       if (!lookups?.length) return;
       for (const entry of lookups) {
         if (LookupRegistry_default.has(entry.id)) continue;
-        const table = JSON.parse(import_fs22.default.readFileSync(entry.path, "utf-8"));
+        const table = JSON.parse(import_fs23.default.readFileSync(entry.path, "utf-8"));
         LookupRegistry_default.set(entry.id, table);
         Logger_default.log(`[lookup] Hydrated table "${entry.consumer}" (${entry.key}->${entry.value}) from ${entry.path}`);
       }
     };
     this.openReadStream = (chunk) => {
       const { end, fileUri, start } = chunk;
-      return import_fs22.default.createReadStream(fileUri, { start, end: end - 1 });
+      return import_fs23.default.createReadStream(fileUri, { start, end: end - 1 });
     };
     this.openWriteStream = (scope, workerId) => {
       const workerPath = ExecutorScope_default.getWorkerPath(scope, workerId);
-      return new BatchWriter_default(import_fs22.default.createWriteStream(workerPath));
+      return new BatchWriter_default(import_fs23.default.createWriteStream(workerPath));
     };
     // The first line of the first chunk is data unless the file type carries a header there.
     this.shouldProcessFirstLine = (producer) => {
@@ -59414,7 +60397,7 @@ init_OutputExecutor();
 init_ProducerExecutor();
 
 // ../../packages/executors/src/SampleRunner.ts
-var import_fs26 = __toESM(require("fs"));
+var import_fs27 = __toESM(require("fs"));
 var import_promises21 = __toESM(require("fs/promises"));
 var import_path25 = __toESM(require("path"));
 init_src();
@@ -59528,9 +60511,9 @@ var SampleRunnerClass = class {
     };
     /** The captured dataset, which `captureFormat: 'JSONL'` guarantees is one JSON object per line. */
     this._readCapture = async (capturePath, size) => {
-      if (!import_fs26.default.existsSync(capturePath)) return [];
+      if (!import_fs27.default.existsSync(capturePath)) return [];
       const records = [];
-      for await (const line of readLines(import_fs26.default.createReadStream(capturePath))) {
+      for await (const line of readLines(import_fs27.default.createReadStream(capturePath))) {
         if (!line.length) continue;
         records.push(JSON.parse(line));
         if (records.length >= size) break;