@forzalabs/remora 2.4.0 → 2.5.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 fs32 = require("fs");
+    var fs33 = 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");
       };
-      fs32.open(options2.file, "a+", "0644", (err2, fd) => {
+      fs33.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) {
-            fs32.close(fd, noop);
+            fs33.close(fd, noop);
             return;
           }
-          return fs32.read(fd, buffer, 0, buffer.length, pos, (error, bytes) => {
+          return fs33.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 fs32 = require("fs");
+    var fs33 = 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 = fs32.createReadStream(file, {
+        const stream = fs33.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);
-        fs32.stat(fullpath, (err2, stat) => {
+        fs33.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 = fs32.createWriteStream(fullpath, this.options).on("error", (err2) => debug(err2)).on("close", () => debug("close", dest.path, dest.bytesWritten)).on("open", () => {
+        const dest = fs33.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);
-        fs32.unlink(target, callback);
+        fs33.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);
-            fs32.exists(tmppath, (exists) => {
+            fs33.exists(tmppath, (exists) => {
               if (!exists) {
                 return cb(null);
               }
               fileName = `${basename}${i6}${ext}${isZipped}`;
-              fs32.rename(tmppath, path22.join(this.dirname, fileName), cb);
+              fs33.rename(tmppath, path22.join(this.dirname, fileName), cb);
             });
           }.bind(this, x2));
         }
         asyncSeries(tasks, () => {
-          fs32.rename(
+          fs33.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) {
-        fs32.access(src, fs32.F_OK, (err2) => {
+        fs33.access(src, fs33.F_OK, (err2) => {
           if (err2) {
             return callback();
           }
           var gzip = zlib3.createGzip();
-          var inp = fs32.createReadStream(src);
-          var out = fs32.createWriteStream(dest);
+          var inp = fs33.createReadStream(src);
+          var out = fs33.createWriteStream(dest);
           out.on("finish", () => {
-            fs32.unlink(src, callback);
+            fs33.unlink(src, callback);
           });
           inp.pipe(gzip).pipe(out);
         });
       }
       _createLogDirIfNotExist(dirPath) {
-        if (!fs32.existsSync(dirPath)) {
-          fs32.mkdirSync(dirPath, { recursive: true });
+        if (!fs33.existsSync(dirPath)) {
+          fs33.mkdirSync(dirPath, { recursive: true });
         }
       }
     };
@@ -11809,7 +11809,7 @@ var CONSTANTS, Constants_default;
 var init_Constants = __esm({
   "../../packages/constants/src/Constants.ts"() {
     CONSTANTS = {
-      cliVersion: "2.4.0",
+      cliVersion: "2.5.0",
       backendVersion: 1,
       backendPort: 5088,
       workerVersion: 2,
@@ -11934,6 +11934,13 @@ var init_Constants = __esm({
          * mode when its next line arrives — its byte counter lives in the bucket, not the stream.
          */
         MAX_OPEN_SPLIT_STREAMS: 64,
+        /**
+         * 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
+         * from opening a descriptor per distinct value of the wrong field.
+         */
+        MAX_FIXED_LAYOUTS: 64,
         /**
          * Rows a sample may ask for out of the pipeline. A sample is a look at the data, never an
          * export of it — `remora sample -s` and the preview's Data tab are both held to this.
@@ -13176,7 +13183,7 @@ var init_Validator = __esm({
               errors.push(`Consumer "${consumer.name}" declares ${consumer.outputs.length} outputs (${consumer.outputs.map((x2) => x2.format).join(", ")}). A consumer writes exactly one output \u2014 only the first was ever written \u2014 so split it into one consumer per output.`);
             for (const output of consumer.outputs) {
               const format4 = output.format.toUpperCase();
-              if (format4 === "CSV" || format4 === "JSON" || format4 === "PARQUET" || format4 === "TXT") {
+              if (format4 === "CSV" || format4 === "FIXED" || format4 === "JSON" || format4 === "PARQUET" || format4 === "TXT") {
                 if (!output.exportDestination)
                   errors.push(`A static file output must have an export destination set (${format4})`);
                 else if (!Environment_default.getSource(output.exportDestination))
@@ -13186,6 +13193,7 @@ var init_Validator = __esm({
             errors.push(...this.validateOmitNull(consumer));
             errors.push(...this.validateHeader(consumer));
             errors.push(...this.validateSplit(consumer));
+            errors.push(...this.validateFixedOutput(consumer));
             const dimensionFields = consumer.fields.filter((x2) => x2.key !== "*" && !x2.fixed && !x2.copyFrom && !x2.lineCount);
             const dimensionKeys = dimensionFields.map((x2) => `${x2.from ?? "_default_"}::${x2.key}`);
             const duplicateDimensionKeys = dimensionKeys.filter((k7, i6) => dimensionKeys.indexOf(k7) !== i6);
@@ -13254,7 +13262,7 @@ var init_Validator = __esm({
         this.validateSplit = (consumer) => {
           const errors = [];
           const { split: split2 } = consumer;
-          const positionalFormats = ["CSV", "TXT", "PARQUET"];
+          const positionalFormats = ["CSV", "FIXED", "TXT", "PARQUET"];
           if (!Algo_default.hasVal(split2)) return errors;
           if (Algo_default.hasVal(consumer.maximumFileSize))
             errors.push(`Consumer "${consumer.name}" sets both "maximumFileSize" and "split". They are the same cap: move the value to "split": { "maxFileSizeGb": ${consumer.maximumFileSize} } and remove "maximumFileSize".`);
@@ -13285,7 +13293,7 @@ var init_Validator = __esm({
          */
         this.validateOmitNull = (consumer) => {
           const errors = [];
-          const positionalFormats = ["CSV", "TXT", "PARQUET"];
+          const positionalFormats = ["CSV", "FIXED", "TXT", "PARQUET"];
           for (const output of (consumer.outputs ?? []).filter((x2) => x2.omitNull === true)) {
             const format4 = output.format.toUpperCase();
             if (positionalFormats.includes(format4))
@@ -13305,10 +13313,49 @@ var init_Validator = __esm({
           for (const output of (consumer.outputs ?? []).filter((x2) => Algo_default.hasVal(x2.header))) {
             const format4 = output.format.toUpperCase();
             if (!headerFormats.includes(format4))
-              errors.push(`The ${format4} output of consumer "${consumer.name}" declares "header", which only applies to CSV/TXT output: a ${format4} ${format4 === "PARQUET" ? "file carries its own schema" : "record already carries its own field names"}.`);
+              errors.push(`The ${format4} output of consumer "${consumer.name}" declares "header", which only applies to CSV/TXT output: ${this.headerlessReason(format4)}.`);
           }
           return errors;
         };
+        /** Why the format in hand has no header line, as the clause that finishes the sentence above. */
+        this.headerlessReason = (format4) => {
+          if (format4 === "FIXED") return "a positional line has no room for one, and a field name would not sit on the columns it describes";
+          if (format4 === "PARQUET") return `a ${format4} file carries its own schema`;
+          return `a ${format4} record already carries its own field names`;
+        };
+        /**
+         * Checks a consumer's FIXED output from its configuration alone: the properties only a
+         * positional file has, the ones it cannot have, and whether anything downstream tries to read
+         * one back. The layout itself — widths, columns and record lengths — is resolved against the
+         * dataset's columns, which the producers define, so it is checked by `compile` and again before
+         * a run starts rather than here.
+         *
+         * A property declared on the wrong format is rejected rather than ignored, the way a `position`
+         * on a non-FIXED producer is: silently dropping a rule the author wrote is how a file ships
+         * looking almost right.
+         */
+        this.validateFixedOutput = (consumer) => {
+          Affirm_default(consumer, "Invalid consumer");
+          const errors = [];
+          const output = consumer.outputs?.[0];
+          if (!output) return errors;
+          const format4 = output.format?.toUpperCase();
+          const positioned = (consumer.fields ?? []).filter((x2) => x2.position).map((x2) => `"${x2.alias ?? x2.key}"`);
+          if (format4 !== "FIXED") {
+            const fixedOnly = ["recordLength", "defaults", "lineEnding", "layouts"];
+            const declared = fixedOnly.filter((name) => Algo_default.hasVal(output[name]));
+            if (declared.length > 0)
+              errors.push(`The ${format4} output of consumer "${consumer.name}" declares ${declared.map((x2) => `"${x2}"`).join(", ")}, which only ${declared.length > 1 ? "apply" : "applies"} to a FIXED output, where ${declared.length > 1 ? "they are" : "it is"} ignored.`);
+            if (positioned.length > 0)
+              errors.push(`Consumer "${consumer.name}" declares "position" on field(s) ${positioned.join(", ")} but its output format is not "FIXED", where positions are ignored.`);
+            return errors;
+          }
+          if (Algo_default.hasVal(output.delimiter))
+            errors.push(`The FIXED output of consumer "${consumer.name}" declares a "delimiter". A positional line has none: its fields are found by the columns they occupy.`);
+          if ((consumer.fields ?? []).some((x2) => x2.key === "*"))
+            errors.push(`Consumer "${consumer.name}" selects fields with the wildcard key "*", which a FIXED output can't write: every field of a positional line declares its own "width", so the field list has to be explicit.`);
+          return errors;
+        };
         /**
          * Checks a field whose key selects columns by pattern ("addr*Street"). A pattern that matches
          * nothing is always a mistake — a renamed dimension, or a producer that never had those columns —
@@ -14889,7 +14936,7 @@ A consumer takes the data from one or more producers and changes it's shape to t
 # RULES
 - If a field is not needed, do not add it e.g.
 - Only import a producer once
-- Awlays include this exact property as the first -> $schema": "https://raw.githubusercontent.com/ForzaLabs/remora-public/refs/heads/main/json_schemas/consumer-schema.json",
+- Awlays include this exact property as the first -> "$schema": "https://raw.githubusercontent.com/ForzaLabs/remora-public/refs/heads/main/json_schemas/consumer-schema.json",
 - Use "API" as the only valid output format.
 - The "from" must contain only the name of the producer
 
@@ -33941,6 +33988,307 @@ var init_FixedWidthParser = __esm({
   }
 });
 
+// ../../packages/parsing/src/FixedWidthWriter.ts
+var BASE_FILL, TYPE_FILL, FixedWidthWriterClass, FixedWidthWriter, FixedWidthWriter_default;
+var init_FixedWidthWriter = __esm({
+  "../../packages/parsing/src/FixedWidthWriter.ts"() {
+    init_src();
+    init_src3();
+    BASE_FILL = { align: "left", pad: " ", nullFill: " ", overflow: "fail" };
+    TYPE_FILL = {
+      string: BASE_FILL,
+      number: { ...BASE_FILL, align: "right", pad: "0" },
+      datetime: BASE_FILL,
+      boolean: BASE_FILL
+    };
+    FixedWidthWriterClass = class {
+      constructor() {
+        /**
+         * Resolves one record layout for writing: every column's fill rules decided, its columns
+         * computed, and the record length agreed with what the output declares.
+         *
+         * Called once per layout when an export starts, never per record. `columns` is the line as the
+         * dataset schema has it — line order, visible fields only — and `positions` carries each one's
+         * `position` block, keyed by the same name the column has.
+         *
+         * `context` is the phrase that names this layout in an error, e.g. `the FIXED output of consumer
+         * "x"`, so a message reads as one sentence wherever the layout came from.
+         */
+        this.compilePlan = (columns, positions, output, context = "the FIXED output") => {
+          Affirm_default(output, "Invalid consumer output");
+          const selected = columns?.map((column, index) => ({ column, index }));
+          return this.plan(selected, positions, output.defaults, output.recordLength, context);
+        };
+        /**
+         * A FIXED output resolved for INSPECTION rather than for writing: every problem with it, and the
+         * layouts it would write. What `compile` reports and prints.
+         *
+         * The rules are not restated here. The layouts are resolved by the same code the export runs,
+         * and what that throws is reported rather than raised — so a layout `compile` accepts is a
+         * layout the export can write. What review adds is that every field's own declaration is
+         * checked first, across the whole output: an author with six fields missing a width sees six
+         * lines from one `compile`, not one line from each of six.
+         *
+         * A field named by a layout that the dataset has no column for is left to the resolution below,
+         * which names it as the layout's error rather than as a field with no width.
+         */
+        this.review = (dsSchema, positions, output, consumerName) => {
+          Affirm_default(dsSchema, "Invalid dataset schema");
+          Affirm_default(output, "Invalid consumer output");
+          const context = `the FIXED output${consumerName ? ` of consumer "${consumerName}"` : ""}`;
+          const declared = this.declarationErrors(dsSchema, positions, output, context);
+          if (declared.length > 0) return { errors: declared, layouts: [] };
+          try {
+            if (!output.layouts)
+              return { errors: [], layouts: [{ value: null, plan: this.compilePlan(dsSchema.columns, positions, output, context) }] };
+            const layouts = this.compileLayouts(dsSchema, positions, output, consumerName);
+            return { errors: [], layouts: layouts.order.map((value) => ({ value, plan: layouts.plans.get(value) })) };
+          } catch (e7) {
+            return { errors: [this.reason(e7)], layouts: [] };
+          }
+        };
+        /** Every field's own declaration, over every field the output writes, before any offset is computed. */
+        this.declarationErrors = (dsSchema, positions, output, context) => {
+          const written = output.layouts ? [...new Set((output.layouts.order ?? []).flatMap((value) => output.layouts.values?.[value]?.fields ?? []))] : dsSchema.columns.map((column) => column.name);
+          const errors = [];
+          for (const name of written) {
+            const column = dsSchema.columns.find((x2) => x2.name === name);
+            if (column) errors.push(...this.fieldErrors(column, positions?.[name], output.defaults, context));
+          }
+          return errors;
+        };
+        /**
+         * What an affirm said, as a sentence a report can start a line with: without the prefix it
+         * carries for a log, and with its first letter upper-cased — the messages are written to be
+         * embedded ("... of the FIXED output of consumer x ..."), so some begin with that context
+         * rather than with a capital.
+         */
+        this.reason = (error) => {
+          const prefix2 = "Affirm failed: ";
+          const message = error instanceof Error ? error.message : String(error);
+          const sentence = message.startsWith(prefix2) ? message.slice(prefix2.length) : message;
+          return sentence.charAt(0).toUpperCase() + sentence.slice(1);
+        };
+        /**
+         * The record layouts of a multi-layout FIXED output, compiled in `order` so the export writes
+         * its blocks in the order the author declared.
+         *
+         * Each layout names a subset of the dataset's columns, in its own column order, so a field's
+         * place on the written line has nothing to do with its place on the staged one — which is what
+         * `IFixedWriteField.index` carries. The output's `defaults` stand under every layout's own.
+         */
+        this.compileLayouts = (dsSchema, positions, output, consumerName) => {
+          Affirm_default(dsSchema, "Invalid dataset schema");
+          Affirm_default(output?.layouts, "Invalid fixed-width layouts");
+          const { discriminator, order, values } = output.layouts;
+          const where = consumerName ? ` of consumer "${consumerName}"` : "";
+          Affirm_default(discriminator, `The FIXED layouts${where} name no discriminator field`);
+          Affirm_default.hasItems(order, `The FIXED layouts${where} declare no "order", which is the order their record blocks are written in`);
+          Affirm_default.noDupes(order, `The FIXED layouts${where} name a discriminator value twice in "order"`);
+          Affirm_default(
+            order.length <= Constants_default.defaults.MAX_FIXED_LAYOUTS,
+            `The FIXED layouts${where} declare ${order.length} record layouts, more than the ${Constants_default.defaults.MAX_FIXED_LAYOUTS} one output may write`
+          );
+          Affirm_default(
+            output.recordLength === void 0 || output.recordLength === null,
+            `The FIXED output${where} declares both "layouts" and a "recordLength". Each layout declares its own; the output has no single one.`
+          );
+          const index = dsSchema.columns.findIndex((column) => column.name === discriminator);
+          Affirm_default(index >= 0, `The FIXED discriminator "${discriminator}"${where} is not one of the consumer's visible fields`);
+          const plans = /* @__PURE__ */ new Map();
+          for (const value of order)
+            plans.set(value, this.layoutPlan(values?.[value], dsSchema, positions, output, value, consumerName));
+          return { discriminator, index, order, plans };
+        };
+        /** One entry of the `layouts` map as a plan: its named fields, found on the staged line, in its order. */
+        this.layoutPlan = (layout, dsSchema, positions, output, value, consumerName) => {
+          const of = consumerName ? ` of consumer "${consumerName}"` : "";
+          const where = `the FIXED layout "${value}"${of}`;
+          Affirm_default(layout, `The FIXED "order"${of} names the discriminator value "${value}", which has no layout under "values"`);
+          Affirm_default.hasItems(layout.fields, `${where} writes no field`);
+          Affirm_default.noDupes(layout.fields, `${where} writes a field twice`);
+          const selected = layout.fields.map((name) => {
+            const index = dsSchema.columns.findIndex((column) => column.name === name);
+            Affirm_default(index >= 0, `The field "${name}" of ${where} is not one of the consumer's visible fields`);
+            return { column: dsSchema.columns[index], index };
+          });
+          return this.plan(selected, positions, this.mergeDefaults(output.defaults, layout.defaults), layout.recordLength, where);
+        };
+        /**
+         * One record layout ready to write: every column's fill rules decided, its columns computed from
+         * the widths before it, and the record length agreed with what the layout declares.
+         */
+        this.plan = (selected, positions, defaults, recordLength, context) => {
+          Affirm_default.hasItems(selected, `${context} has no field to write`);
+          Affirm_default(positions, "Invalid fixed-width field positions");
+          const fields = [];
+          let start = 1;
+          for (const { column, index } of selected) {
+            const field = this.resolveField(column, positions[column.name], defaults, start, context);
+            fields.push({ ...field, index });
+            start = field.end + 1;
+          }
+          const composed = start - 1;
+          Affirm_default(
+            recordLength === void 0 || recordLength === null || recordLength === composed,
+            `${context} declares a recordLength of ${recordLength}, but its ${fields.length} field widths sum to ${composed}. A field, a filler or a width is missing.`
+          );
+          return { fields, recordLength: composed };
+        };
+        /**
+         * The layout's per-type fill rules over the output's, type by type — so an output states a rule
+         * once for the whole file and a layout only names where it differs.
+         */
+        this.mergeDefaults = (output, layout) => {
+          if (!layout) return output;
+          if (!output) return layout;
+          const merged = { ...output };
+          for (const type of Object.keys(layout))
+            merged[type] = this.override(output[type] ?? {}, layout[type]);
+          return merged;
+        };
+        /**
+         * The layout a record is written with, by the value of the discriminator field on its staged
+         * line. A value with no layout stops the run: it is a record the file has no block for, and
+         * writing it under another layout would put its fields at the wrong columns.
+         */
+        this.planFor = (values, layouts) => {
+          const value = values?.[layouts.index];
+          const plan = value === null || value === void 0 ? null : layouts.plans.get(String(value));
+          Affirm_default(plan, `No FIXED layout for the value ${value === null || value === void 0 ? "null" : `"${value}"`} of the discriminator field "${layouts.discriminator}". The layouts cover ${layouts.order.map((x2) => `"${x2}"`).join(", ")}.`);
+          return plan;
+        };
+        /**
+         * Everything wrong with the way ONE field is declared, as messages rather than as a throw: no
+         * `position` at all, a width that is not a whole number of columns, a fill character that is not
+         * one character.
+         *
+         * Not the field's place on the line — that is only meaningful once every field before it stands
+         * on its own, so `resolveField` checks it where it computes it. This is the one statement of the
+         * rules: the export affirms them, and `review` collects them for every field of an output so
+         * `compile` reports six missing widths in one run rather than one per run.
+         */
+        this.fieldErrors = (column, position, defaults, context) => {
+          Affirm_default(column, "Invalid dataset column");
+          const where = `field "${column.name}"${context ? ` of ${context}` : ""}`;
+          if (!position)
+            return [`Missing "position" on ${where}: every visible field of a FIXED output declares the width it occupies`];
+          const errors = [];
+          if (!Number.isInteger(position.width) || position.width < 1)
+            errors.push(`"position.width" of ${where} must be a whole number of 1 or greater`);
+          const fill2 = this.fillOf(column.type, position, defaults);
+          if (fill2.pad.length !== 1)
+            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}"`);
+          return errors;
+        };
+        /**
+         * One column with its fill rules resolved and its place on the line computed. The field's own
+         * `position` wins over the output's `defaults` for its type, which wins over the type's own rule,
+         * so a wide layout states a rule once and names only its exceptions.
+         */
+        this.resolveField = (column, position, defaults, start, context) => {
+          const declaration = this.fieldErrors(column, position, defaults, context);
+          Affirm_default(declaration.length === 0, declaration.join(" "));
+          const where = `field "${column.name}"${context ? ` of ${context}` : ""}`;
+          const fill2 = this.fillOf(column.type, position, defaults);
+          const end = start + position.width - 1;
+          Affirm_default(
+            position.start === void 0 || position.start === null || position.start === start,
+            `"position.start" of ${where} says column ${position.start}, but the widths before it place the field at column ${start}. A field or a filler is missing, or two are out of order.`
+          );
+          return {
+            name: column.name,
+            width: position.width,
+            start,
+            end,
+            align: fill2.align,
+            pad: fill2.pad,
+            nullText: fill2.nullFill.repeat(position.width),
+            overflow: fill2.overflow
+          };
+        };
+        /** The three fill sources folded into one, nearest declaration first. */
+        this.fillOf = (type, position, defaults) => {
+          const base = TYPE_FILL[type] ?? TYPE_FILL.string;
+          return this.override(this.override(base, defaults?.[type]), position);
+        };
+        /** `fill` with whatever `override` actually declares. An absent rule leaves the one below it standing. */
+        this.override = (fill2, override) => {
+          if (!override) return fill2;
+          const merged = { ...fill2 };
+          if (override.align) merged.align = override.align;
+          if (override.pad) merged.pad = override.pad;
+          if (override.nullFill) merged.nullFill = override.nullFill;
+          if (override.overflow) merged.overflow = override.overflow;
+          return merged;
+        };
+        /**
+         * One record as its positional line, with no delimiter, no quoting and no terminator. The values
+         * are the record's fields as the STAGED line holds them, each plan field reading the one it was
+         * compiled against; a value the array does not reach is written as a null, which is what a
+         * staged line does when its last fields carry nothing.
+         */
+        this.composeLine = (values, plan) => {
+          Affirm_default(values, "Invalid record values");
+          Affirm_default(plan, "Invalid fixed-width write plan");
+          let line = "";
+          for (const field of plan.fields)
+            line += this.writeField(values[field.index], field);
+          Affirm_default(line.length === plan.recordLength, `A fixed-width record composed to ${line.length} characters, not the declared recordLength of ${plan.recordLength}`);
+          return line;
+        };
+        /**
+         * One value as one field: its text padded out to the field's width on the side `align` names.
+         *
+         * A null is the full width in `nullFill`, and an EMPTY STRING is a null — the staged encoding
+         * keeps the two apart and a positional line cannot. A value too long for its field stops the
+         * 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 (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);
+        };
+        /**
+         * A value longer than its field. It fails the run by default: a truncated account number is a
+         * plausible-looking account number, and silent corruption in a feed nobody re-reads is the one
+         * failure mode a positional writer must not have.
+         *
+         * 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.
+         */
+        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);
+        };
+        /**
+         * What a record carries after its last field, BEFORE the newline the destination writes. Every
+         * destination driver ends each transformed line with one `\n`, the last line included, so an
+         * `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
+         * every line including the last, and `lf` is the default everywhere else.
+         */
+        this.lineSuffix = (output) => {
+          Affirm_default(output, "Invalid consumer output");
+          return output.lineEnding === "crlf" ? "\r" : "";
+        };
+      }
+    };
+    FixedWidthWriter = new FixedWidthWriterClass();
+    FixedWidthWriter_default = FixedWidthWriter;
+  }
+});
+
 // ../../node_modules/pend/index.js
 var require_pend = __commonJS({
   "../../node_modules/pend/index.js"(exports2, module2) {
@@ -33999,7 +34347,7 @@ var require_pend = __commonJS({
 // ../../node_modules/yauzl/fd-slicer.js
 var require_fd_slicer = __commonJS({
   "../../node_modules/yauzl/fd-slicer.js"(exports2) {
-    var fs32 = require("fs");
+    var fs33 = require("fs");
     var util = require("util");
     var stream = require("stream");
     var Readable10 = stream.Readable;
@@ -34019,7 +34367,7 @@ var require_fd_slicer = __commonJS({
     FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
       var self2 = this;
       self2.pend.go(function(cb) {
-        fs32.read(self2.fd, buffer, offset, length, position, function(err2, bytesRead, buffer2) {
+        fs33.read(self2.fd, buffer, offset, length, position, function(err2, bytesRead, buffer2) {
           cb();
           callback(err2, bytesRead, buffer2);
         });
@@ -34036,7 +34384,7 @@ var require_fd_slicer = __commonJS({
       self2.refCount -= 1;
       if (self2.refCount < 0) throw new Error("invalid unref");
       if (self2.refCount > 0) return;
-      fs32.close(self2.fd, onCloseDone);
+      fs33.close(self2.fd, onCloseDone);
       function onCloseDone(err2) {
         if (err2) {
           self2.emit("error", err2);
@@ -34068,7 +34416,7 @@ var require_fd_slicer = __commonJS({
       }
       self2.context.pend.go(function(cb) {
         var buffer = Buffer.allocUnsafe(toRead);
-        fs32.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err2, bytesRead) {
+        fs33.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err2, bytesRead) {
           if (err2) {
             self2.destroy(err2);
           } else if (bytesRead === 0) {
@@ -34428,7 +34776,7 @@ var require_crc32 = __commonJS({
 // ../../node_modules/yauzl/index.js
 var require_yauzl = __commonJS({
   "../../node_modules/yauzl/index.js"(exports2) {
-    var fs32 = require("fs");
+    var fs33 = require("fs");
     var zlib3 = require("zlib");
     var fd_slicer = require_fd_slicer();
     var util = require("util");
@@ -34497,10 +34845,10 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs32.open(path22, "r", function(err2, fd) {
+      fs33.open(path22, "r", function(err2, fd) {
         if (err2) return callback(err2);
         fromFd(fd, options2, function(err3, zipfile) {
-          if (err3) fs32.close(fd, defaultCallback);
+          if (err3) fs33.close(fd, defaultCallback);
           callback(err3, zipfile);
         });
       });
@@ -34517,7 +34865,7 @@ var require_yauzl = __commonJS({
       if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
       if (options2.strictFileNames == null) options2.strictFileNames = false;
       if (callback == null) callback = defaultCallback;
-      fs32.fstat(fd, function(err2, stats) {
+      fs33.fstat(fd, function(err2, stats) {
         if (err2) return callback(err2);
         var reader = new fd_slicer.FdSlicer(fd);
         fromRandomAccessReader(reader, stats.size, options2, callback);
@@ -38598,6 +38946,7 @@ var init_src5 = __esm({
     init_CSVParser();
     init_DatasetCodec();
     init_FixedWidthParser();
+    init_FixedWidthWriter();
     init_ParseCompression();
     init_ParseHelper();
     init_XLSParser();
@@ -46233,8 +46582,8 @@ var init_LocalSourceDriver = __esm({
             Logger_default.log(`Matched ${allFileKeys.length} files, copying to locally and creating unified dataset.`);
             const firstPath = import_path10.default.join(this._path, allFileKeys[0]);
             const headerLine = (await DriverHelper_default.quickReadFile(firstPath, 1))[0];
-            const promises2 = allFileKeys.map((x2, i6) => this._get({ ...request, fileKey: x2 }, headerLine, i6));
-            const results = await Promise.all(promises2);
+            const promises3 = allFileKeys.map((x2, i6) => this._get({ ...request, fileKey: x2 }, headerLine, i6));
+            const results = await Promise.all(promises3);
             return results.flat();
           } else {
             return await this._get(request, "");
@@ -46254,8 +46603,8 @@ var init_LocalSourceDriver = __esm({
             Logger_default.log(`Matched ${allFileKeys.length} files, copying to locally and creating unified dataset.`);
             const firstPath = import_path10.default.join(this._path, allFileKeys[0]);
             const headerLine = (await DriverHelper_default.quickReadFile(firstPath, 1))[0];
-            const promises2 = allFileKeys.map((x2, i6) => this._get({ ...request, fileKey: x2 }, headerLine, i6));
-            const results = await Promise.all(promises2);
+            const promises3 = allFileKeys.map((x2, i6) => this._get({ ...request, fileKey: x2 }, headerLine, i6));
+            const results = await Promise.all(promises3);
             return results.flat();
           } else {
             return await this._get(request, "");
@@ -46683,8 +47032,8 @@ var init_S3SourceDriver = __esm({
           if (fileKey.includes("%")) {
             const allFileKeys = await this.listFiles(fileKey);
             Affirm_default(allFileKeys.length < 50, `Pattern ${fileKey} of producer requested to S3 matches more than 50 files (${allFileKeys.length}), this is more than the S3 allowed limit. Please refine your pattern, remove some files or use a separate bucket.`);
-            const promises2 = allFileKeys.map((x2, i6) => this._get({ ...request, fileKey: x2 }, i6));
-            const results = await Promise.all(promises2);
+            const promises3 = allFileKeys.map((x2, i6) => this._get({ ...request, fileKey: x2 }, i6));
+            const results = await Promise.all(promises3);
             return results.flat();
           } else {
             return await this._get(request);
@@ -46697,8 +47046,8 @@ var init_S3SourceDriver = __esm({
           const { fileKey } = request;
           if (fileKey.includes("%")) {
             const allFileKeys = await this.listFiles(fileKey);
-            const promises2 = allFileKeys.map((x2, i6) => this._get({ ...request, fileKey: x2 }, i6));
-            const results = await Promise.all(promises2);
+            const promises3 = allFileKeys.map((x2, i6) => this._get({ ...request, fileKey: x2 }, i6));
+            const results = await Promise.all(promises3);
             return results.flat();
           } else {
             return await this._get(request);
@@ -56102,6 +56451,8 @@ var init_DatasetSchema = __esm({
               return "JSON";
             case "TXT":
               return "CSV";
+            case "FIXED":
+              return "CSV";
             case "CSV":
               return "CSV";
             default:
@@ -56181,6 +56532,112 @@ var init_DatasetSchema = __esm({
   }
 });
 
+// ../../packages/executors/src/FixedBlockOrder.ts
+var fs25, FixedBlockOrderClass, FixedBlockOrder, FixedBlockOrder_default;
+var init_FixedBlockOrder = __esm({
+  "../../packages/executors/src/FixedBlockOrder.ts"() {
+    fs25 = __toESM(require("fs"));
+    init_src();
+    init_src5();
+    init_src2();
+    FixedBlockOrderClass = class {
+      constructor() {
+        /** The file one block's records are collected in. Named by the value's place in `order`, not by
+         * the value itself: a discriminator value is data and may hold anything a path may not. */
+        this.blockPath = (sourcePath, position) => `${sourcePath}.block_${position}`;
+        /**
+         * Routes the staged dataset into one file per layout and concatenates them in `layouts.order`,
+         * returning the path of the block-ordered dataset the export then transforms.
+         */
+        this.reorder = async (request) => {
+          Affirm_default(request, "Invalid block order request");
+          Affirm_default(request.sourcePath, "Missing dataset to order into blocks");
+          Affirm_default(request.layouts, "Invalid fixed-width layouts");
+          Affirm_default.hasItems(request.layouts.order, "The fixed-width layouts declare no block order");
+          const { sourcePath, layouts, consumerName } = request;
+          const orderedPath = `${sourcePath}.blocks`;
+          const counts = await this._route(request);
+          await fs25.promises.unlink(sourcePath);
+          await this._concat(sourcePath, layouts, orderedPath);
+          Logger_default.info(`Consumer "${consumerName}" writes its FIXED record blocks as ${layouts.order.map((value, position) => `${value} x${counts[position]}`).join(", ")}`);
+          return orderedPath;
+        };
+        /**
+         * The routing pass: every line read once, appended to the file of the block its discriminator
+         * names. One stream per layout, all open at once — `MAX_FIXED_LAYOUTS` is what bounds them, so
+         * there is no eviction to do and a block's file is only ever written by its own stream.
+         *
+         * Returns the records each block took, in `order`, which is what the log line reports.
+         */
+        this._route = async (request) => {
+          const { sourcePath, layouts } = request;
+          const streams = layouts.order.map((_3, position) => fs25.createWriteStream(this.blockPath(sourcePath, position)));
+          const positions = new Map(layouts.order.map((value, position) => [value, position]));
+          const counts = layouts.order.map(() => 0);
+          const readStream = fs25.createReadStream(sourcePath);
+          try {
+            for await (const line of readLines(readStream)) {
+              const position = this._positionOf(line, layouts, positions);
+              counts[position]++;
+              const stream = streams[position];
+              if (!stream.write(line + "\n"))
+                await new Promise((resolve) => stream.once("drain", resolve));
+            }
+          } finally {
+            for (const stream of streams)
+              await this._closeStream(stream);
+            readStream.destroy();
+          }
+          return counts;
+        };
+        /** The block a staged line belongs to. A record no layout covers stops the run; see `planFor`. */
+        this._positionOf = (line, layouts, positions) => {
+          const value = DatasetCodec_default.decodeRow(line)[layouts.index];
+          const position = value === null || value === void 0 ? void 0 : positions.get(String(value));
+          Affirm_default(
+            position !== void 0,
+            `No FIXED layout for the value ${value === null || value === void 0 ? "null" : `"${value}"`} of the discriminator field "${layouts.discriminator}". The layouts cover ${layouts.order.map((x2) => `"${x2}"`).join(", ")}.`
+          );
+          return position;
+        };
+        /** The blocks appended into one dataset, in `order`, each file removed as it is consumed. */
+        this._concat = async (sourcePath, layouts, orderedPath) => {
+          const writer = fs25.createWriteStream(orderedPath);
+          try {
+            for (let position = 0; position < layouts.order.length; position++) {
+              const blockPath = this.blockPath(sourcePath, position);
+              await this._append(blockPath, writer);
+              await fs25.promises.unlink(blockPath);
+            }
+          } finally {
+            await this._closeStream(writer);
+          }
+        };
+        /** One block's bytes onto the end of the ordered dataset. Piped, so a block is never held in memory. */
+        this._append = (blockPath, writer) => {
+          return new Promise((resolve, reject) => {
+            const reader = fs25.createReadStream(blockPath);
+            reader.on("error", reject);
+            reader.on("end", resolve);
+            reader.pipe(writer, { end: false });
+          });
+        };
+        /** Flushes and releases a stream's descriptor. Awaited: the read that follows must not race the flush. */
+        this._closeStream = async (stream) => {
+          if (!stream) return;
+          stream.end();
+          await new Promise((resolve, reject) => {
+            stream.on("finish", resolve);
+            stream.on("error", reject);
+          });
+        };
+      }
+    };
+    FixedBlockOrder = new FixedBlockOrderClass();
+    FixedBlockOrder_default = FixedBlockOrder;
+  }
+});
+
 // ../../packages/executors/src/OutputExecutor.ts
 var OutputExecutorClass, OutputExecutor, OutputExecutor_default;
 var init_OutputExecutor = __esm({
@@ -56193,6 +56650,7 @@ var init_OutputExecutor = __esm({
     init_src5();
     init_src2();
     init_DatasetSchema();
+    init_FixedBlockOrder();
     OutputExecutorClass = class {
       constructor() {
         /**
@@ -56283,6 +56741,8 @@ var init_OutputExecutor = __esm({
           const destinationName = this._composeFileName(consumer, output, this._getExtension(output));
           Logger_default.info(`Exporting consumer "${consumer.name}" to "${output.exportDestination}" as ${output.format} (${destinationName}, ${splitFiles.length} file(s))`);
           const header = this._composeHeader(output, 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;
           const results = [];
           for (const { path: startingPath, label } of splitFiles) {
             const destinationPath = this.getCompletedPath(destinationName, label);
@@ -56303,6 +56763,11 @@ var init_OutputExecutor = __esm({
                 );
                 break;
               }
+              case "FIXED": {
+                const fixedPath = fixedLayouts ? await FixedBlockOrder_default.reorder({ sourcePath: startingPath, layouts: fixedLayouts, consumerName: consumer.name }) : startingPath;
+                results.push(await driver.transformAndMove(fixedPath, fixedLine, destinationPath));
+                break;
+              }
               case "PARQUET":
                 results.push(await this._exportParquet({
                   sourcePath: startingPath,
@@ -56318,6 +56783,60 @@ var init_OutputExecutor = __esm({
           }
           return this._unifingResult(results);
         };
+        /**
+         * A consumer's FIXED output resolved without running it: the layouts the export would compile,
+         * and every problem with them. `compile` prints what it resolves and fails on what it reports,
+         * and a run resolves it before reading a producer — so a width that does not add up is caught
+         * where it was written rather than after the whole dataset has been built.
+         *
+         * Null for a consumer that writes anything else: there is no layout to resolve.
+         */
+        this.reviewFixedOutput = (consumer, dsSchema) => {
+          Affirm_default(consumer, "Invalid consumer");
+          const output = consumer.outputs?.[0];
+          if (output?.format !== "FIXED") return null;
+          const schema = dsSchema ?? DatasetSchema_default.compile(consumer, ConsumerManager_default.getExpandedFields(consumer));
+          return FixedWidthWriter_default.review(schema, this._fixedPositions(consumer), output, consumer.name);
+        };
+        /**
+         * The line function a FIXED export hands its destination driver: one staged record in, the
+         * positional line it becomes out. The layout is resolved here, once, and closed over — so the
+         * per-record cost is a decode of the staged line and a pad per field, with no config lookup.
+         *
+         * With `layouts` declared the record's own discriminator picks its plan, which is the only
+         * per-record branch on the path; the records are already grouped into their blocks by then.
+         *
+         * No header is passed alongside it: a positional file has no room for one, and the field names
+         * would not sit on the columns they describe.
+         */
+        this._fixedLineWriter = (consumer, dsSchema, output, layouts) => {
+          const suffix = FixedWidthWriter_default.lineSuffix(output);
+          if (layouts) {
+            for (const value of layouts.order)
+              Logger_default.info(`Consumer "${consumer.name}" writes its FIXED "${value}" record as ${layouts.plans.get(value).recordLength} characters over ${layouts.plans.get(value).fields.length} field(s)`);
+            return (line) => {
+              const values = DatasetCodec_default.decodeRow(line);
+              return FixedWidthWriter_default.composeLine(values, FixedWidthWriter_default.planFor(values, layouts)) + suffix;
+            };
+          }
+          const plan = FixedWidthWriter_default.compilePlan(dsSchema.columns, this._fixedPositions(consumer), output, `the FIXED output of consumer "${consumer.name}"`);
+          Logger_default.info(`Consumer "${consumer.name}" writes a FIXED record of ${plan.recordLength} characters over ${plan.fields.length} field(s)`);
+          return (line) => FixedWidthWriter_default.composeLine(DatasetCodec_default.decodeRow(line), plan) + suffix;
+        };
+        /**
+         * Every visible field's `position` block, keyed by the name its column carries on the staged
+         * line. Read from the EXPANDED fields rather than the consumer's own, so a glob key brings the
+         * `position` it was declared with to each of the columns it stands for, and a field the dataset
+         * has no `position` for is left absent for `compilePlan` to name.
+         */
+        this._fixedPositions = (consumer) => {
+          const positions = {};
+          for (const field of ConsumerManager_default.getExpandedFields(consumer)) {
+            if (field.cField.hidden) continue;
+            positions[field.finalKey] = field.cField.position;
+          }
+          return positions;
+        };
         /**
          * Ships one split file as parquet. A parquet file is a columnar container whose footer can only
          * be written once the last row group is encoded, so there is no per-line mapping to hand a
@@ -56355,8 +56874,9 @@ var init_OutputExecutor = __esm({
         /**
          * The header line of a positional export: the visible field names, in column order, quoted and
          * delimited exactly as the rows under them — so the header parses with the same reader the data
-         * does. Null for a JSON/API output, where a record already carries its own field names, and for
-         * an output that turns the header off.
+         * does. Null for a JSON/API output, where a record already carries its own field names, for a
+         * FIXED one, where a name does not fit the column it describes and the receiver reads by
+         * position anyway, and for an output that turns the header off.
          *
          * The names come from the dataset's own schema, so a `pivot` is described by the header.
          */
@@ -57010,10 +57530,10 @@ var init_ExecutorPerformance = __esm({
 });
 
 // ../../packages/executors/src/ExecutorWriter.ts
-var fs27, ExecutorWriter, ExecutorWriter_default;
+var fs28, ExecutorWriter, ExecutorWriter_default;
 var init_ExecutorWriter = __esm({
   "../../packages/executors/src/ExecutorWriter.ts"() {
-    fs27 = __toESM(require("fs"));
+    fs28 = __toESM(require("fs"));
     init_src();
     init_src3();
     init_src10();
@@ -57065,7 +57585,7 @@ var init_ExecutorWriter = __esm({
           await this._route(pass, dsSchema);
           if (pass.buckets.size === 0)
             return [{ path: sourcePath, label: this.UNSPLIT_LABEL }];
-          await fs27.promises.unlink(sourcePath);
+          await fs28.promises.unlink(sourcePath);
           return this._listFiles(pass);
         };
         /**
@@ -57073,7 +57593,7 @@ var init_ExecutorWriter = __esm({
          */
         this._route = async (pass, dsSchema) => {
           const parseLine = pass.keys.length === 0 ? null : LineParser_default.datasetParser(dsSchema);
-          const readStream = fs27.createReadStream(pass.sourcePath);
+          const readStream = fs28.createReadStream(pass.sourcePath);
           try {
             for await (const line of readLines(readStream)) {
               const bucket = this._bucketFor(line, pass, parseLine);
@@ -57177,7 +57697,7 @@ var init_ExecutorWriter = __esm({
           }
           if (pass.openStreams.length >= Constants_default.defaults.MAX_OPEN_SPLIT_STREAMS)
             await this._closeStream(pass.openStreams.shift());
-          bucket.stream = fs27.createWriteStream(this.getCompletedPath(pass.sourcePath, this._composeLabel(bucket, pass)), { flags: "a" });
+          bucket.stream = fs28.createWriteStream(this.getCompletedPath(pass.sourcePath, this._composeLabel(bucket, pass)), { flags: "a" });
           pass.openStreams.push(bucket);
           return bucket.stream;
         };
@@ -57762,6 +58282,11 @@ var init_ExecutorOrchestrator = __esm({
             const start = performance.now();
             const executorResults = [];
             Logger_default.info(`[${usageId}] Launching consumer "${consumer.name}" (invoked by: ${details.invokedBy}, user: ${details.user?.name ?? "unknown"}, producer(s): ${consumer.producers.length}${OrchestratorHelper_default.formatRequestOptions(options2)}) | ${OrchestratorHelper_default.formatMemoryUsage()}`);
+            const fixedReview = request.skipExport ? null : OutputExecutor_default.reviewFixedOutput(consumer, dsSchema);
+            Affirm_default(
+              !fixedReview || fixedReview.errors.length === 0,
+              `Consumer "${consumer.name}" cannot write its FIXED output: ${fixedReview?.errors.join(" ")}`
+            );
             const lookups = await LookupResolver_default.materialize(consumer, expandedFields, scope, request);
             const consumerInputs = await ConsumerInputResolver_default.materialize(consumer, scope, request);
             let counter = performance.now();