Add encoder (ewe), symmetric to decoder (ewd)

`ewe` re-compresses an XML file back into a `.ewprj` or `.ms14` the
original software can open, using node-pkware's `implode` with ASCII
literals and the large dictionary (matching what Multisim/Ultiboard
emit). Decompressed sections are chunked at 900 000 bytes to mirror
the section layout observed in real files. Output format is inferred
from the target extension; default output path strips a trailing
`.xml` from the input.

A decode/encode/decode round-trip is byte-identical on every sample
tested. Re-encoded files are larger than the originals because
node-pkware's implode skips an unimplemented repetition search; the
output is still valid PKWare DCL Implode and `ewd` accepts it.

Also renamed `src/main.ts` to `src/ewd.ts` so the two CLIs share a
naming convention, and added `npm run ewd` / `npm run ewe` scripts.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: cinderblock

README.md

@@ -1,24 +1,69 @@
-# Electronics Workbench Decoder (and Encoder?)
+# Electronics Workbench Decoder and Encoder
 
-Decompresses National Instruments Electronics Workbench / Multisim / Ultiboard
-project files (`.ewprj`, `.ms14`) into their underlying XML.
+Two CLIs:
 
-The container is a small header (`CompressedElectronicsWorkbenchXML` or
-`MSMCompressedElectronicsWorkbenchXML`) followed by a 64-bit total decompressed
-length, then a sequence of `(decompressed_length: u32, compressed_length: u32, pkware_implode_block)` sections. Compression is PKWare DCL Implode (ASCII,
-large dictionary).
+- **`ewd`** — decode an EWB project (`.ewprj`, `.ms14`) into its underlying XML.
+- **`ewe`** — encode XML back into a `.ewprj`/`.ms14` the original software can re-open.
 
-For each input file, a `<filename>.xml` is written next to the input.
+The container is a small header (`CompressedElectronicsWorkbenchXML` or
+`MSMCompressedElectronicsWorkbenchXML`), then a 64-bit little-endian total
+decompressed length, then a sequence of `(decompressed_length: u32, compressed_length: u32, pkware_implode_block)` sections. Compression is
+PKWare DCL Implode (ASCII literal mode, large dictionary). Multisim chunks
+big files into 900 000-decompressed-byte sections; `ewe` mirrors that.
 
-## Development
+## Install
 
 ```bash
 npm i
-npm run dev -- --verbose ./samples/Temp.ewprj ./samples/Design1.ms14
 ```
 
-CLI options:
+## Decode
+
+```bash
+npm run ewd -- --verbose ./samples/Temp.ewprj ./samples/Design1.ms14
+```
+
+For each input, writes `<filename>.xml` next to it.
+
+Options:
 
 - `-v`, `--verbose` — log per-section progress
 - `-c`, `--concurrent` — decode multiple files in parallel
 - positional args — files to decode
+
+## Encode
+
+```bash
+npm run ewe -- --verbose ./samples/Temp.ewprj.xml
+# or with explicit output:
+npm run ewe -- --output ./out.ewprj ./samples/Temp.ewprj.xml
+```
+
+By default, strips a trailing `.xml` from each input to derive the output
+path. Format is inferred from the output extension (`.ewprj` vs `.ms14`).
+
+Options:
+
+- `-v`, `--verbose` — log per-section progress
+- `-c`, `--concurrent` — encode multiple files in parallel
+- `-o`, `--output <path>` — explicit output path (single-input only)
+- positional args — XML files to encode
+
+### Compression ratio caveat
+
+`ewe` uses [`node-pkware`](https://github.com/cinderblock/node-pkware)'s
+`implode` for compression. Its repetition search is currently incomplete
+(see the upstream `TODO: search for a better repetition` log lines), so
+re-encoded files are several times larger than the originals. They are
+still valid: a decode/encode/decode round-trip on every sample tested
+produces byte-identical XML, and the resulting files are accepted by
+`ewd`. Improving compression density is a `node-pkware` problem.
+
+## Development
+
+```bash
+npm run dev:ewd -- --verbose ./samples/Temp.ewprj
+npm run dev:ewe -- --verbose ./samples/Temp.ewprj.xml
+```
+
+Both use `ts-node-dev` for fast reload.

package.json

@@ -1,13 +1,17 @@
 {
   "name": "electronics-workbench-decoder",
   "version": "0.0.0",
-  "description": "Scripts to decode compressed EWB files",
+  "description": "Decode (ewd) and encode (ewe) compressed Electronics Workbench / Multisim / Ultiboard files",
   "author": "Cameron Tacklind <cameron@tacklind.com>",
   "license": "ISC",
   "main": "decode",
   "scripts": {
-    "start": "ts-node src/main.ts",
-    "dev": "ts-node-dev --rs --respawn src/main.ts --"
+    "start": "ts-node src/ewd.ts",
+    "dev": "ts-node-dev --rs --respawn src/ewd.ts --",
+    "ewd": "ts-node src/ewd.ts",
+    "ewe": "ts-node src/ewe.ts",
+    "dev:ewd": "ts-node-dev --rs --respawn src/ewd.ts --",
+    "dev:ewe": "ts-node-dev --rs --respawn src/ewe.ts --"
   },
   "engines": {
     "node": ">=8.0.0",

src/encode.ts

@@ -0,0 +1,91 @@
+import { promises as fs } from 'fs';
+import winston from 'winston';
+import { constants, implode, stream } from 'node-pkware';
+import { Readable } from 'stream';
+
+const { COMPRESSION_ASCII, DICTIONARY_SIZE_LARGE } = constants;
+const { streamToBuffer, through } = stream;
+
+// Decompressed bytes per block. Multisim/Ultiboard ship files chunked at this
+// boundary; matching it keeps the section layout identical to originals.
+export const DEFAULT_BLOCK_SIZE = 900000;
+
+function compressBlock(block: Buffer): Promise<Buffer> {
+  return new Promise<Buffer>((resolve, reject) => {
+    const src = Readable.from(block);
+    const compressor = through(
+      implode(COMPRESSION_ASCII, DICTIONARY_SIZE_LARGE, {
+        inputBufferSize: block.length,
+        outputBufferSize: block.length,
+      }),
+    );
+    src.on('error', reject);
+    compressor.on('error', reject);
+    src.pipe(compressor).pipe(streamToBuffer(resolve));
+  });
+}
+
+function headerFor(targetFilename: string): Buffer {
+  if (targetFilename.endsWith('.ewprj')) {
+    return Buffer.from('CompressedElectronicsWorkbenchXML');
+  }
+  if (targetFilename.endsWith('.ms14')) {
+    return Buffer.from('MSMCompressedElectronicsWorkbenchXML');
+  }
+  throw new Error(`I don't know what header to use for: ${targetFilename}`);
+}
+
+function inferOutFile(inFile: string): string {
+  if (inFile.endsWith('.xml')) return inFile.slice(0, -'.xml'.length);
+  throw new Error(`Cannot infer output filename from ${inFile}, pass --output`);
+}
+
+export async function encode(
+  inFile: string,
+  logger: winston.Logger,
+  outFile = inferOutFile(inFile),
+  blockSize = DEFAULT_BLOCK_SIZE,
+): Promise<void> {
+  if (!inFile) throw new Error('No input filename provided');
+  if (blockSize <= 0) throw new RangeError('blockSize must be > 0');
+
+  const header = headerFor(outFile);
+
+  logger.verbose(`Encoding ${inFile} -> ${outFile}`);
+
+  const xml = await fs.readFile(inFile);
+  const totalLength = xml.length;
+  logger.silly(`Read ${totalLength} bytes from ${inFile}`);
+
+  const output = await fs.open(outFile, 'w');
+  try {
+    await output.write(header);
+
+    const sizeBuf = Buffer.allocUnsafe(8);
+    sizeBuf.writeBigUInt64LE(BigInt(totalLength));
+    await output.write(sizeBuf);
+
+    let section = 0;
+    for (let offset = 0; offset < totalLength; offset += blockSize) {
+      const end = Math.min(offset + blockSize, totalLength);
+      const slice = xml.subarray(offset, end);
+
+      const compressed = await compressBlock(slice);
+
+      logger.silly(`Section #${section}: ${slice.length} bytes -> ${compressed.length} compressed`);
+
+      const sectionHeader = Buffer.allocUnsafe(8);
+      sectionHeader.writeUInt32LE(slice.length, 0);
+      sectionHeader.writeUInt32LE(compressed.length, 4);
+
+      await output.write(sectionHeader);
+      await output.write(compressed);
+
+      section++;
+    }
+
+    logger.verbose(`Wrote ${outFile} (${section} section${section === 1 ? '' : 's'})`);
+  } finally {
+    await output.close();
+  }
+}

src/main.ts src/ewd.tssrc/main.ts renamed to src/ewd.ts

@@ -0,0 +1,55 @@
+import winston from 'winston';
+import commandLineArgs from 'command-line-args';
+import { encode } from './encode';
+
+export async function main() {
+  const { files, output, verbose, concurrent } = commandLineArgs([
+    { name: 'verbose', alias: 'v', type: Boolean },
+    { name: 'concurrent', alias: 'c', type: Boolean },
+    { name: 'output', alias: 'o', type: String },
+    { name: 'files', type: String, multiple: true, defaultOption: true },
+  ]) as {
+    files: string[];
+    output?: string;
+    verbose: boolean;
+    concurrent: boolean;
+  };
+
+  const logger = winston.createLogger({
+    level: verbose ? 'verbose' : 'info',
+    format: winston.format.json(),
+    transports: [
+      new winston.transports.Console({
+        format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
+      }),
+    ],
+  });
+
+  if (!files) {
+    logger.error('No files specified');
+    process.exitCode = 1;
+    return;
+  }
+
+  if (output && files.length > 1) {
+    logger.error('--output cannot be combined with multiple input files');
+    process.exitCode = 1;
+    return;
+  }
+
+  if (concurrent) {
+    await Promise.all(files.map(f => encode(f, logger, output)));
+  } else {
+    for (const f of files) {
+      logger.info(`Next file: ${f}`);
+      await encode(f, logger, output);
+    }
+  }
+}
+
+if (require.main === module) {
+  main().catch(e => {
+    console.error(e);
+    process.exitCode = 1;
+  });
+}