@dusted/anqst 1.5.0 → 1.5.1

package/dist/src/program.js

@@ -81,7 +81,7 @@ function readTsConfigFrom(specPath) {
 function createTscProgramContext(specPath) {
     const absoluteSpecPath = node_path_1.default.resolve(specPath);
     const tsConfig = readTsConfigFrom(absoluteSpecPath);
-    const rootNames = tsConfig ? [...new Set([...tsConfig.rootNames, absoluteSpecPath])] : [absoluteSpecPath];
+    const rootNames = [absoluteSpecPath];
     const options = tsConfig?.options ?? {
         target: typescript_1.default.ScriptTarget.ES2022,
         module: typescript_1.default.ModuleKind.CommonJS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dusted/anqst",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "Opinionated backend generator for webapps.",
   "keywords": [
     "nodejs",
@@ -47,7 +47,7 @@
     "build": "node scripts/build-with-stamp.js",
     "build:test": "npm run clean && tsc -p tsconfig.json && npm run chmod:bin",
     "prepare": "npm run build",
-    "test": "npm run build:test && node --test dist/test/**/*.test.js",
+    "test": "npm run build:test && node --test dist/test/*.test.js",
     "start": "node dist/src/bin/anqst.js"
   },
   "dependencies": {

package/dist/src/codecgenerators/basecodecemitters/bigint-qint64/decoder.js

@@ -1,35 +0,0 @@
-"use strict";
-/**
- * Base codec emitter: AnQst.Type.qint64 — TypeScript decoder (standalone base93 string → bigint).
- *
- * - Decodes base93 to 8 bytes, then reads signed 64-bit two's complement via BigInt64Array.
- * - C++ decoder uses memcpy from decoded bytes into qint64 (see emitCppDecoder).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decoderEmitter = exports.descriptor = void 0;
-const fixedwidth_1 = require("../shared/fixedwidth");
-const FIXED_WIDTH = {
-    byteWidth: 8,
-    tsViewCtor: "BigInt64Array",
-    cppType: "qint64"
-};
-exports.descriptor = {
-    codecId: "bigint-qint64",
-    specPath: "RefinedSpecs/Codecs/BigInt_qint64_Codec.md",
-    tsType: "bigint",
-    cppType: "qint64",
-    wireCategory: "fixed-width-scalar",
-    strategySummary: "Decode standalone base93 to 8 bytes, reinterpret as qint64 / BigInt64Array[0] as bigint.",
-    fixedWidth: FIXED_WIDTH
-};
-const TS_FN = "decodeQint64Standalone";
-const CPP_FN = "decodeQint64Standalone";
-exports.decoderEmitter = {
-    descriptor: exports.descriptor,
-    emitTsDecoder() {
-        return (0, fixedwidth_1.emitTsFixedWidthStandaloneDecoder)(TS_FN, FIXED_WIDTH);
-    },
-    emitCppDecoder() {
-        return (0, fixedwidth_1.emitCppFixedWidthStandaloneDecoder)(CPP_FN, FIXED_WIDTH);
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/bigint-qint64/encoder.js

@@ -1,36 +0,0 @@
-"use strict";
-/**
- * Base codec emitter: AnQst.Type.qint64 — TypeScript encoder (bigint → standalone base93 string).
- *
- * - 8-byte signed two's complement via BigInt64Array; platform-native byte order.
- * - Standalone wire: one base93 string (10 characters for 8 bytes).
- * - C++ side mirrors layout with memcpy into qint64 (see emitCppEncoder).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encoderEmitter = exports.descriptor = void 0;
-const fixedwidth_1 = require("../shared/fixedwidth");
-const FIXED_WIDTH = {
-    byteWidth: 8,
-    tsViewCtor: "BigInt64Array",
-    cppType: "qint64"
-};
-exports.descriptor = {
-    codecId: "bigint-qint64",
-    specPath: "RefinedSpecs/Codecs/BigInt_qint64_Codec.md",
-    tsType: "bigint",
-    cppType: "qint64",
-    wireCategory: "fixed-width-scalar",
-    strategySummary: "Serialize qint64 as 8-byte signed two's complement (BigInt64Array / C++ memcpy), then base93-encode to a standalone JSON string.",
-    fixedWidth: FIXED_WIDTH
-};
-const TS_FN = "encodeQint64Standalone";
-const CPP_FN = "encodeQint64Standalone";
-exports.encoderEmitter = {
-    descriptor: exports.descriptor,
-    emitTsEncoder() {
-        return (0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)(TS_FN, FIXED_WIDTH);
-    },
-    emitCppEncoder() {
-        return (0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)(CPP_FN, FIXED_WIDTH);
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/bigint-quint64/decoder.js

@@ -1,26 +0,0 @@
-"use strict";
-/**
- * Decoder emitter for the AnQst base-type codec `AnQst.Type.quint64`.
- *
- * Reverses the standalone encoder: base93 string → 8 bytes → `BigUint64Array` → bigint (≥ 0n).
- * C++ decodes to `quint64` via `std::memcpy` from decoded bytes.
- *
- * Spec: RefinedSpecs/Codecs/BigInt_quint64_Codec.md
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decoder = exports.descriptor = void 0;
-const fixedwidth_1 = require("../shared/fixedwidth");
-const encoder_1 = require("./encoder");
-Object.defineProperty(exports, "descriptor", { enumerable: true, get: function () { return encoder_1.descriptor; } });
-const fixedWidth = encoder_1.descriptor.fixedWidth;
-const TS_FN = "decodeQuint64Standalone";
-const CPP_FN = "decodeQuint64Standalone";
-exports.decoder = {
-    descriptor: encoder_1.descriptor,
-    emitTsDecoder() {
-        return (0, fixedwidth_1.emitTsFixedWidthStandaloneDecoder)(TS_FN, fixedWidth);
-    },
-    emitCppDecoder() {
-        return (0, fixedwidth_1.emitCppFixedWidthStandaloneDecoder)(CPP_FN, fixedWidth);
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/bigint-quint64/encoder.js

@@ -1,38 +0,0 @@
-"use strict";
-/**
- * Emitter for the AnQst base-type codec `AnQst.Type.quint64`.
- *
- * Maps TypeScript `bigint` to an 8-byte unsigned little-endian representation via
- * `BigUint64Array`, then to a standalone base93 string (10 characters). C++ uses
- * `quint64` with `std::memcpy` for the same 8-byte layout on the host platform.
- *
- * Spec: RefinedSpecs/Codecs/BigInt_quint64_Codec.md
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encoder = exports.descriptor = void 0;
-const fixedwidth_1 = require("../shared/fixedwidth");
-const fixedWidth = {
-    byteWidth: 8,
-    tsViewCtor: "BigUint64Array",
-    cppType: "quint64"
-};
-exports.descriptor = {
-    codecId: "bigint-quint64",
-    specPath: "RefinedSpecs/Codecs/BigInt_quint64_Codec.md",
-    tsType: "bigint",
-    cppType: "quint64",
-    wireCategory: "fixed-width-scalar",
-    strategySummary: "8-byte unsigned host-endian representation (BigUint64Array / memcpy into quint64), base93 standalone string (10 chars).",
-    fixedWidth
-};
-const TS_FN = "encodeQuint64Standalone";
-const CPP_FN = "encodeQuint64Standalone";
-exports.encoder = {
-    descriptor: exports.descriptor,
-    emitTsEncoder() {
-        return (0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)(TS_FN, fixedWidth);
-    },
-    emitCppEncoder() {
-        return (0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)(CPP_FN, fixedWidth);
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/binary-blob/decoder.js

@@ -1,28 +0,0 @@
-"use strict";
-/**
- * Base codec emitter (decode): `AnQst.Type.blob`.
- * Decoding mirrors `AnQst.Type.buffer`: base93 text reconstructs the original raw bytes as ArrayBuffer/QByteArray.
- * This file preserves blob-specific descriptor identity while reusing the shared raw-byte scaffold.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decoderEmitter = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-const rawbytes_1 = require("../shared/rawbytes");
-const encoder_1 = require("./encoder");
-Object.defineProperty(exports, "descriptor", { enumerable: true, get: function () { return encoder_1.descriptor; } });
-const TS_FN = "decodeBinaryBlobStandalone";
-const CPP_FN = "decodeBinaryBlobStandalone";
-const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (decode): AnQst.Type.blob / QByteArray", [
-    "Base93-decodes the standalone wire string back into the original opaque byte sequence.",
-    "Wire layout is intentionally identical to AnQst.Type.buffer; the distinction is semantic descriptor metadata.",
-    "Expects base93Decode in scope; C++ reconstructs QByteArray directly from decoded bytes."
-]);
-exports.decoderEmitter = {
-    descriptor: encoder_1.descriptor,
-    emitTsDecoder() {
-        return `${strategyComment}\n\n${(0, rawbytes_1.emitTsRawByteStandaloneDecoder)(TS_FN, "bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)")}`;
-    },
-    emitCppDecoder() {
-        return `${strategyComment}\n\n${(0, rawbytes_1.emitCppRawByteStandaloneDecoder)(CPP_FN, "QByteArray(reinterpret_cast<const char*>(bytes.data()), static_cast<int>(bytes.size()))")}`;
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/binary-blob/encoder.js

@@ -1,34 +0,0 @@
-"use strict";
-/**
- * Base codec emitter (encode): `AnQst.Type.blob`.
- * Wire shape is identical to `AnQst.Type.buffer`: raw ArrayBuffer bytes become one base93 string.
- * This emitter keeps distinct blob descriptor metadata while reusing the shared raw-byte scaffold.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encoderEmitter = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-const rawbytes_1 = require("../shared/rawbytes");
-exports.descriptor = {
-    codecId: "binary-blob",
-    specPath: "RefinedSpecs/Codecs/Binary_blob_Codec.md",
-    tsType: "ArrayBuffer",
-    cppType: "QByteArray",
-    wireCategory: "binary",
-    strategySummary: "Serialize ArrayBuffer / QByteArray raw bytes as one base93 string; wire-identical to buffer, but with blob-specific descriptor metadata."
-};
-const TS_FN = "encodeBinaryBlobStandalone";
-const CPP_FN = "encodeBinaryBlobStandalone";
-const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.blob / QByteArray", [
-    "Treats the payload as opaque bytes and base93-encodes them into one standalone JSON string.",
-    "Wire layout is intentionally identical to AnQst.Type.buffer; only descriptor identity differs.",
-    "Expects base93Encode in scope; C++ path reads QByteArray bytes without adding length/type metadata."
-]);
-exports.encoderEmitter = {
-    descriptor: exports.descriptor,
-    emitTsEncoder() {
-        return `${strategyComment}\n\n${(0, rawbytes_1.emitTsRawByteStandaloneEncoder)(TS_FN, "new Uint8Array(value)")}`;
-    },
-    emitCppEncoder() {
-        return `${strategyComment}\n\n${(0, rawbytes_1.emitCppRawByteStandaloneEncoder)(CPP_FN, "std::vector<std::uint8_t>(reinterpret_cast<const std::uint8_t*>(value.constData()), reinterpret_cast<const std::uint8_t*>(value.constData()) + value.size())")}`;
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/binary-buffer/decoder.js

@@ -1,29 +0,0 @@
-"use strict";
-/**
- * Base codec emitter (decode): standalone base93 string → `ArrayBuffer` / `QByteArray`.
- * The decoder reconstructs the exact raw byte sequence and returns the decoded backing buffer in TS.
- * Composite codecs must decide where buffer-length metadata lives when a variable-length buffer shares a
- * payload with sibling fields; this file only emits the standalone leaf helper and documents that strategy.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decoder = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-const rawbytes_1 = require("../shared/rawbytes");
-const encoder_1 = require("./encoder");
-Object.defineProperty(exports, "descriptor", { enumerable: true, get: function () { return encoder_1.descriptor; } });
-const TS_FN = "decodeAnqstBase_buffer";
-const CPP_FN = "decodeAnqstBase_buffer";
-const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (decode): AnQst.Type.buffer / ArrayBuffer", [
-    "Base93-decodes the standalone wire string to raw bytes and returns the resulting opaque byte sequence.",
-    "TypeScript returns the ArrayBuffer backing the decoded Uint8Array without an extra copy; C++ rebuilds QByteArray from decoded bytes.",
-    "Composite codecs should read byte-length metadata from their planned numeric blob or trailing-position convention before consuming a buffer payload; that structured orchestration is intentionally not wired here."
-]);
-exports.decoder = {
-    descriptor: encoder_1.descriptor,
-    emitTsDecoder() {
-        return `${strategyComment}\n\n${(0, rawbytes_1.emitTsRawByteStandaloneDecoder)(TS_FN, "bytes.buffer")}`;
-    },
-    emitCppDecoder() {
-        return `${strategyComment}\n\n${(0, rawbytes_1.emitCppRawByteStandaloneDecoder)(CPP_FN, "QByteArray(bytes.begin(), bytes.end())")}`;
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/binary-buffer/encoder.js

@@ -1,36 +0,0 @@
-"use strict";
-/**
- * Base codec emitter (encode): `AnQst.Type.buffer` / `ArrayBuffer` ↔ `QByteArray`.
- * Standalone wire shape is one base93 string over the raw bytes, including `""` for an empty buffer.
- * Composite codecs should keep the variable-length buffer payload in its own string slot and pair it with
- * byte-length metadata when sibling fields make boundaries ambiguous; that structured integration is
- * documented here but intentionally not emitted by this leaf helper.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encoder = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-const rawbytes_1 = require("../shared/rawbytes");
-exports.descriptor = {
-    codecId: "AnQst.Type.buffer",
-    specPath: "RefinedSpecs/Codecs/Binary_buffer_Codec.md",
-    tsType: "ArrayBuffer",
-    cppType: "QByteArray",
-    wireCategory: "binary",
-    strategySummary: "ArrayBuffer/QByteArray raw bytes encoded as one standalone base93 string; composite codecs keep the payload in its own string slot and carry byte length separately when needed."
-};
-const TS_FN = "encodeAnqstBase_buffer";
-const CPP_FN = "encodeAnqstBase_buffer";
-const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.buffer / ArrayBuffer", [
-    "Treats the domain value as an opaque byte sequence and base93-encodes it as one standalone string.",
-    "TypeScript reads bytes through Uint8Array(value); C++ reads QByteArray through begin()/end() into std::vector<std::uint8_t>.",
-    "Composite codecs should keep this variable-length payload in its own wire string position and carry byte-length metadata separately when boundary disambiguation is required; that orchestration is not emitted here."
-]);
-exports.encoder = {
-    descriptor: exports.descriptor,
-    emitTsEncoder() {
-        return `${strategyComment}\n\n${(0, rawbytes_1.emitTsRawByteStandaloneEncoder)(TS_FN, "new Uint8Array(value)")}`;
-    },
-    emitCppEncoder() {
-        return `${strategyComment}\n\n${(0, rawbytes_1.emitCppRawByteStandaloneEncoder)(CPP_FN, "std::vector<std::uint8_t>(value.begin(), value.end())")}`;
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/binary-float32Array/decoder.js

@@ -1,46 +0,0 @@
-"use strict";
-/**
- * AnQstGen base-type codec emitter for `binary-float32Array`.
- * Decoder consumes one base93 string of raw bytes and reconstructs a concrete `Float32Array`.
- * Multi-byte element byte order and all IEEE 754 bit patterns are preserved exactly as transmitted.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decoder = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-const encoder_1 = require("./encoder");
-Object.defineProperty(exports, "descriptor", { enumerable: true, get: function () { return encoder_1.descriptor; } });
-const TS_FN = "decodeBinaryFloat32ArrayStandalone";
-const CPP_FN = "decodeBinaryFloat32ArrayStandalone";
-exports.decoder = {
-    descriptor: encoder_1.descriptor,
-    emitTsDecoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Float32Array decoder (raw-byte base93)", [
-                "Decodes base93 to bytes, then constructs a concrete Float32Array view over the decoded buffer.",
-                "Rejected decoded byte counts not divisible by 4 indicate corrupted wire data because Float32Array elements require 4 bytes each."
-            ]),
-            `function ${TS_FN}(encoded) {`,
-            "  const bytes = base93Decode(encoded);",
-            "  if ((bytes.byteLength & 3) !== 0) {",
-            "    throw new RangeError(\"Decoded Float32Array byte length must be divisible by 4.\");",
-            "  }",
-            "  return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);",
-            "}"
-        ].join("\n");
-    },
-    emitCppDecoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Float32Array decoder (QByteArray raw bytes)", [
-                "C++ receives the raw bytes as QByteArray; float interpretation stays outside the byte-transport codec.",
-                "Portable tests may supply a lightweight QByteArray shim with a (const char*, int) constructor."
-            ]),
-            `inline QByteArray ${CPP_FN}(const std::string& encoded) {`,
-            "  const std::vector<std::uint8_t> bytes = base93Decode(encoded);",
-            "  return QByteArray(",
-            "    reinterpret_cast<const char*>(bytes.data()),",
-            "    static_cast<int>(bytes.size())",
-            "  );",
-            "}"
-        ].join("\n");
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/binary-float32Array/encoder.js

@@ -1,49 +0,0 @@
-"use strict";
-/**
- * AnQstGen base-type codec emitter for `binary-float32Array`.
- * Wire form is one base93 string carrying the raw bytes of a `Float32Array` view.
- * The TypeScript path must respect `byteOffset`/`byteLength`; the C++ path keeps the spec-facing `QByteArray` signature.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encoder = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-exports.descriptor = {
-    codecId: "binary-float32Array",
-    specPath: "RefinedSpecs/Codecs/Binary_float32Array_Codec.md",
-    tsType: "Float32Array",
-    cppType: "QByteArray",
-    wireCategory: "binary",
-    strategySummary: "Base93-encode the raw bytes of the Float32Array view (respecting byteOffset/byteLength); C++ receives the same raw bytes in QByteArray."
-};
-const TS_FN = "encodeBinaryFloat32ArrayStandalone";
-const CPP_FN = "encodeBinaryFloat32ArrayStandalone";
-exports.encoder = {
-    descriptor: exports.descriptor,
-    emitTsEncoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Float32Array encoder (raw-byte base93)", [
-                "Reads only the concrete view window via byteOffset/byteLength, so subviews do not leak adjacent buffer bytes.",
-                "Preserves the stored IEEE 754 binary32 bit patterns exactly, including NaN payloads, infinities, and signed zero."
-            ]),
-            `function ${TS_FN}(value) {`,
-            "  const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);",
-            "  return base93Encode(bytes);",
-            "}"
-        ].join("\n");
-    },
-    emitCppEncoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Float32Array encoder (QByteArray raw bytes)", [
-                "Host-side integration passes the raw float32 bytes as QByteArray; portable tests can provide a minimal QByteArray shim.",
-                "No byte swapping or float normalization is performed; the QByteArray contents are forwarded as-is into base93."
-            ]),
-            `inline std::string ${CPP_FN}(const QByteArray& value) {`,
-            "  std::vector<std::uint8_t> bytes(static_cast<std::size_t>(value.size()));",
-            "  if (!bytes.empty()) {",
-            "    std::memcpy(bytes.data(), value.constData(), bytes.size());",
-            "  }",
-            "  return base93Encode(bytes);",
-            "}"
-        ].join("\n");
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/binary-float64Array/decoder.js

@@ -1,46 +0,0 @@
-"use strict";
-/**
- * AnQstGen base-type codec emitter for `binary-float64Array`.
- * Decoder consumes one base93 string of raw bytes and reconstructs a concrete `Float64Array`.
- * Multi-byte element byte order is preserved exactly as transmitted; no byte swapping is introduced.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decoder = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-const encoder_1 = require("./encoder");
-Object.defineProperty(exports, "descriptor", { enumerable: true, get: function () { return encoder_1.descriptor; } });
-const TS_FN = "decodeBinaryFloat64ArrayStandalone";
-const CPP_FN = "decodeBinaryFloat64ArrayStandalone";
-exports.decoder = {
-    descriptor: encoder_1.descriptor,
-    emitTsDecoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Float64Array decoder (raw-byte base93)", [
-                "Decodes base93 to bytes, then constructs a concrete Float64Array over the decoded buffer.",
-                "Rejected decoded byte counts that are not divisible by 8 indicate corrupted wire data because Float64Array elements require 8 bytes each."
-            ]),
-            `function ${TS_FN}(encoded) {`,
-            "  const bytes = base93Decode(encoded);",
-            "  if ((bytes.byteLength & 7) !== 0) {",
-            '    throw new RangeError("Decoded Float64Array byte length must be divisible by 8.");',
-            "  }",
-            "  return new Float64Array(bytes.buffer);",
-            "}"
-        ].join("\n");
-    },
-    emitCppDecoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Float64Array decoder (QByteArray raw bytes)", [
-                "C++ receives the raw bytes as QByteArray; element interpretation stays outside the byte-transport codec.",
-                "Portable tests may supply a lightweight QByteArray shim with a (const char*, int) constructor."
-            ]),
-            `inline QByteArray ${CPP_FN}(const std::string& encoded) {`,
-            "  const std::vector<std::uint8_t> bytes = base93Decode(encoded);",
-            "  return QByteArray(",
-            "    reinterpret_cast<const char*>(bytes.data()),",
-            "    static_cast<int>(bytes.size())",
-            "  );",
-            "}"
-        ].join("\n");
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/binary-float64Array/encoder.js

@@ -1,47 +0,0 @@
-"use strict";
-/**
- * AnQstGen base-type codec emitter for `binary-float64Array`.
- * Wire form is one base93 string carrying the raw bytes of a `Float64Array` view.
- * The TypeScript path must respect `byteOffset`/`byteLength`; the C++ path keeps the spec-facing `QByteArray` signature.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encoder = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-const rawbytes_1 = require("../shared/rawbytes");
-exports.descriptor = {
-    codecId: "binary-float64Array",
-    specPath: "RefinedSpecs/Codecs/Binary_float64Array_Codec.md",
-    tsType: "Float64Array",
-    cppType: "QByteArray",
-    wireCategory: "binary",
-    strategySummary: "Base93-encode the raw bytes of the Float64Array view (respecting byteOffset/byteLength); C++ receives the same raw bytes in QByteArray."
-};
-const TS_FN = "encodeBinaryFloat64ArrayStandalone";
-const CPP_FN = "encodeBinaryFloat64ArrayStandalone";
-exports.encoder = {
-    descriptor: exports.descriptor,
-    emitTsEncoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Float64Array encoder (raw-byte base93)", [
-                "Reads only the active Float64Array view window via byteOffset/byteLength, so subviews do not leak adjacent buffer bytes.",
-                "Preserves the stored IEEE 754 binary64 bytes exactly, including NaN payloads, infinities, signed zero, and subnormals."
-            ]),
-            (0, rawbytes_1.emitTsRawByteStandaloneEncoder)(TS_FN, "new Uint8Array(value.buffer, value.byteOffset, value.byteLength)")
-        ].join("\n\n");
-    },
-    emitCppEncoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Float64Array encoder (QByteArray raw bytes)", [
-                "Host-side integration passes the Float64Array payload as QByteArray because the backend mapping is raw bytes, not a numeric container.",
-                "No byte swapping or normalization is performed; the QByteArray contents are forwarded as-is into base93."
-            ]),
-            `inline std::string ${CPP_FN}(const QByteArray& value) {`,
-            "  std::vector<std::uint8_t> bytes(static_cast<std::size_t>(value.size()));",
-            "  if (!bytes.empty()) {",
-            "    std::memcpy(bytes.data(), value.constData(), bytes.size());",
-            "  }",
-            "  return base93Encode(bytes);",
-            "}"
-        ].join("\n");
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/binary-int16Array/decoder.js

@@ -1,46 +0,0 @@
-"use strict";
-/**
- * AnQstGen base-type codec emitter for `binary-int16Array`.
- * Decoder consumes one base93 string of raw bytes and reconstructs a concrete `Int16Array`.
- * Multi-byte element byte order is preserved exactly as transmitted; no byte swapping is introduced.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decoder = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-const encoder_1 = require("./encoder");
-Object.defineProperty(exports, "descriptor", { enumerable: true, get: function () { return encoder_1.descriptor; } });
-const TS_FN = "decodeBinaryInt16ArrayStandalone";
-const CPP_FN = "decodeBinaryInt16ArrayStandalone";
-exports.decoder = {
-    descriptor: encoder_1.descriptor,
-    emitTsDecoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Int16Array decoder (raw-byte base93)", [
-                "Decodes base93 to bytes, then reconstructs a concrete Int16Array over the decoded buffer.",
-                "Rejected odd decoded byte counts indicate corrupted wire data because Int16Array elements require 2 bytes each."
-            ]),
-            `function ${TS_FN}(encoded) {`,
-            "  const bytes = base93Decode(encoded);",
-            "  if ((bytes.byteLength & 1) !== 0) {",
-            "    throw new RangeError(\"Decoded Int16Array byte length must be divisible by 2.\");",
-            "  }",
-            "  return new Int16Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 2);",
-            "}"
-        ].join("\n");
-    },
-    emitCppDecoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Int16Array decoder (QByteArray raw bytes)", [
-                "C++ receives the raw bytes as QByteArray; signed 16-bit interpretation stays outside the byte-transport codec.",
-                "Portable tests may supply a lightweight QByteArray shim with a (const char*, int) constructor."
-            ]),
-            `inline QByteArray ${CPP_FN}(const std::string& encoded) {`,
-            "  const std::vector<std::uint8_t> bytes = base93Decode(encoded);",
-            "  return QByteArray(",
-            "    reinterpret_cast<const char*>(bytes.data()),",
-            "    static_cast<int>(bytes.size())",
-            "  );",
-            "}"
-        ].join("\n");
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/binary-int16Array/encoder.js

@@ -1,49 +0,0 @@
-"use strict";
-/**
- * AnQstGen base-type codec emitter for `binary-int16Array`.
- * Wire form is one base93 string carrying the raw bytes of an `Int16Array` view.
- * The TypeScript path must respect `byteOffset`/`byteLength`; the C++ path keeps the spec-facing `QByteArray` signature.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encoder = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-exports.descriptor = {
-    codecId: "binary-int16Array",
-    specPath: "RefinedSpecs/Codecs/Binary_int16Array_Codec.md",
-    tsType: "Int16Array",
-    cppType: "QByteArray",
-    wireCategory: "binary",
-    strategySummary: "Base93-encode the raw bytes of the Int16Array view (respecting byteOffset/byteLength); C++ receives the same raw bytes in QByteArray."
-};
-const TS_FN = "encodeBinaryInt16ArrayStandalone";
-const CPP_FN = "encodeBinaryInt16ArrayStandalone";
-exports.encoder = {
-    descriptor: exports.descriptor,
-    emitTsEncoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Int16Array encoder (raw-byte base93)", [
-                "Reads only the concrete view window via byteOffset/byteLength, so subviews do not leak adjacent buffer bytes.",
-                "Preserves platform-native two-byte element layout by forwarding the stored raw bytes unchanged into base93."
-            ]),
-            `function ${TS_FN}(value) {`,
-            "  const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);",
-            "  return base93Encode(bytes);",
-            "}"
-        ].join("\n");
-    },
-    emitCppEncoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Int16Array encoder (QByteArray raw bytes)", [
-                "Host-side integration passes the raw typed-array bytes as QByteArray; portable tests can provide a minimal QByteArray shim.",
-                "No byte swapping is performed; the QByteArray contents are forwarded as-is into base93."
-            ]),
-            `inline std::string ${CPP_FN}(const QByteArray& value) {`,
-            "  std::vector<std::uint8_t> bytes(static_cast<std::size_t>(value.size()));",
-            "  if (!bytes.empty()) {",
-            "    std::memcpy(bytes.data(), value.constData(), bytes.size());",
-            "  }",
-            "  return base93Encode(bytes);",
-            "}"
-        ].join("\n");
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/binary-int32Array/decoder.js

@@ -1,50 +0,0 @@
-"use strict";
-/**
- * Base codec emitter: `AnQst.Type.int32Array` decoder.
- * Decodes one raw-byte base93 string back into a concrete `Int32Array`, preserving
- * the exact transmitted byte sequence and rejecting byte counts that cannot form 32-bit elements.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decoder = exports.decoderEmitter = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-const encoder_1 = require("./encoder");
-Object.defineProperty(exports, "descriptor", { enumerable: true, get: function () { return encoder_1.descriptor; } });
-const TS_FN = "decodeBinaryInt32ArrayStandalone";
-const CPP_FN = "decodeBinaryInt32ArrayStandalone";
-exports.decoderEmitter = {
-    descriptor: encoder_1.descriptor,
-    emitTsDecoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Int32Array decoder (raw-byte base93)", [
-                "Base93-decodes the standalone wire payload back to raw bytes and reconstructs a concrete Int32Array.",
-                "Decoded byte counts must be divisible by 4 because each Int32Array element occupies exactly 4 bytes.",
-                "Slices the decoded byte window before constructing Int32Array so reconstruction is robust even if the decoded Uint8Array is not offset-zero."
-            ]),
-            `function ${TS_FN}(encoded) {`,
-            "  const bytes = base93Decode(encoded);",
-            "  if ((bytes.byteLength & 3) !== 0) {",
-            "    throw new RangeError(\"Decoded Int32Array byte length must be divisible by 4.\");",
-            "  }",
-            "  const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);",
-            "  return new Int32Array(buffer);",
-            "}"
-        ].join("\n");
-    },
-    emitCppDecoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Int32Array decoder (QByteArray raw bytes)", [
-                "C++ receives the same raw 32-bit element storage bytes as QByteArray; typed interpretation remains outside this byte-transport helper.",
-                "Portable interop tests can use a lightweight QByteArray shim with a (const char*, int) constructor.",
-                "No sign conversion or byte swapping occurs during wire decode; the original raw bytes are restored exactly."
-            ]),
-            `inline QByteArray ${CPP_FN}(const std::string& encoded) {`,
-            "  const std::vector<std::uint8_t> bytes = base93Decode(encoded);",
-            "  return QByteArray(",
-            "    reinterpret_cast<const char*>(bytes.data()),",
-            "    static_cast<int>(bytes.size())",
-            "  );",
-            "}"
-        ].join("\n");
-    }
-};
-exports.decoder = exports.decoderEmitter;