@dusted/anqst 1.0.0 → 1.5.0

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

@@ -0,0 +1,46 @@
+"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

@@ -0,0 +1,49 @@
+"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

@@ -0,0 +1,46 @@
+"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

@@ -0,0 +1,47 @@
+"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

@@ -0,0 +1,46 @@
+"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

@@ -0,0 +1,49 @@
+"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

@@ -0,0 +1,50 @@
+"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;

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

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Base codec emitter: `AnQst.Type.int32Array` encoder.
+ * Emits the visible `Int32Array` view window as standalone raw-byte base93 while
+ * preserving signed bit patterns and portable `QByteArray` interop on the C++ side.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoder = exports.encoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+exports.descriptor = {
+    codecId: "binary-int32Array",
+    specPath: "RefinedSpecs/Codecs/Binary_int32Array_Codec.md",
+    tsType: "Int32Array",
+    cppType: "QByteArray",
+    wireCategory: "binary",
+    strategySummary: "Base93-encode the raw bytes of the visible Int32Array view; decode reconstructs a concrete Int32Array, while C++ interoperates through the same QByteArray raw-byte payload."
+};
+const TS_FN = "encodeBinaryInt32ArrayStandalone";
+const CPP_FN = "encodeBinaryInt32ArrayStandalone";
+exports.encoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return [
+            (0, comments_1.emitStrategyComment)("AnQst Int32Array encoder (raw-byte base93)", [
+                "Encodes only the active Int32Array view window via byteOffset/byteLength so subviews do not leak adjacent backing-buffer bytes.",
+                "Signed values are transported as their raw stored bytes with no reinterpretation, normalization, or byte swapping.",
+                "Wire bytes remain portable because the C++ side consumes and emits the same QByteArray byte sequence."
+            ]),
+            `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 Int32Array encoder (QByteArray raw bytes)", [
+                "Host-side integration passes Int32Array storage as QByteArray so the byte transport stays identical across TypeScript and C++.",
+                "No sign conversion or endianness adjustment is applied; the stored bytes are forwarded unchanged into base93.",
+                "Uses an explicit copy so portable test shims only need QByteArray::constData() and QByteArray::size()."
+            ]),
+            `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");
+    }
+};
+exports.encoder = exports.encoderEmitter;

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

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Base codec emitter (decode): base93 blob → TypeScript `Int8Array`, C++ `QByteArray`.
+ * Reconstructs raw bytes with base93Decode, then reinterprets the backing buffer as Int8Array.
+ * The wire format is identical to the buffer and typedArray binary codecs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binaryInt8ArrayDecoderEmitter = 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 strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (decode): AnQst.Type.int8Array / QByteArray", [
+    "Decodes base93 into raw bytes, then reconstructs Int8Array with new Int8Array(bytes.buffer).",
+    "Preserves signed byte patterns because the underlying bytes are transported unchanged.",
+    "C++ side rebuilds a QByteArray from the decoded byte vector using the same wire contract."
+]);
+exports.binaryInt8ArrayDecoderEmitter = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${strategyComment}
+
+function decodeAnQstBinaryInt8Array(encoded) {
+  const bytes = base93Decode(encoded);
+  return new Int8Array(bytes.buffer);
+}`;
+    },
+    emitCppDecoder() {
+        return `${strategyComment}
+
+inline QByteArray decodeAnQstBinaryInt8Array(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())
+  );
+}`;
+    }
+};

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

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Base codec emitter (encode): AnQst.Type.int8Array ↔ TypeScript `Int8Array`, C++ `QByteArray`.
+ * Serializes the raw bytes of the Int8Array view with base93, preserving byteOffset/byteLength.
+ * Wire format matches the buffer and typedArray binary codecs; only the TS view type differs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binaryInt8ArrayEncoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+exports.descriptor = {
+    codecId: "AnQst.Type.int8Array",
+    specPath: "RefinedSpecs/Codecs/Binary_int8Array_Codec.md",
+    tsType: "Int8Array",
+    cppType: "QByteArray",
+    wireCategory: "binary",
+    strategySummary: "Serialize the raw bytes of the Int8Array view as base93, respecting byteOffset/byteLength and preserving signed byte bit patterns."
+};
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.int8Array / QByteArray", [
+    "Views Int8Array as Uint8Array over the same buffer slice so only the active view bytes are emitted.",
+    "Uses the shared base93 binary transport contract; signed byte interpretation is irrelevant on the wire.",
+    "C++ side mirrors this as raw QByteArray bytes encoded with the same base93 algorithm."
+]);
+exports.binaryInt8ArrayEncoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${strategyComment}
+
+function encodeAnQstBinaryInt8Array(value) {
+  const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  return base93Encode(bytes);
+}`;
+    },
+    emitCppEncoder() {
+        return `${strategyComment}
+
+inline std::string encodeAnQstBinaryInt8Array(const QByteArray& value) {
+  const auto* begin = reinterpret_cast<const std::uint8_t*>(value.constData());
+  return base93Encode(std::vector<std::uint8_t>(
+    begin,
+    begin + static_cast<std::size_t>(value.size())
+  ));
+}`;
+    }
+};

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

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Base codec emitter: `AnQst.Type.typedArray` decoder.
+ * Decoding requires a concrete TypedArray constructor because abstract `TypedArray`
+ * alone does not identify element width or the runtime view type to reconstruct.
+ */
+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 = "decodeBinaryTypedArrayStandalone";
+const CPP_FN = "decodeBinaryTypedArrayStandalone";
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (decode): AnQst.Type.typedArray / QByteArray", [
+    "Base93-decodes the standalone raw-byte payload back to a Uint8Array of bytes.",
+    "The emitted TypeScript API requires a concrete typed-array constructor because abstract TypedArray is insufficient to reconstruct element width and view type.",
+    "C++ rebuilds QByteArray directly because the backend mapping remains raw bytes."
+]);
+exports.decoderEmitter = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${strategyComment}
+
+function ${TS_FN}(encoded, typedArrayCtor) {
+  const bytes = base93Decode(encoded);
+  return new typedArrayCtor(bytes.buffer);
+}`;
+    },
+    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-typedArray/encoder.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Base codec emitter: `AnQst.Type.typedArray` encoder.
+ * Emits the active TypedArray view window as standalone base93 raw bytes.
+ * The wire bytes match `buffer`; only the TypeScript domain type is a typed-array view.
+ */
+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-typedArray",
+    specPath: "RefinedSpecs/Codecs/Binary_typedArray_Codec.md",
+    tsType: "TypedArray",
+    cppType: "QByteArray",
+    wireCategory: "binary",
+    strategySummary: "Encode the raw bytes of the active TypedArray view as standalone base93, preserving byteOffset/byteLength; decode requires a concrete typed-array constructor."
+};
+const TS_FN = "encodeBinaryTypedArrayStandalone";
+const CPP_FN = "encodeBinaryTypedArrayStandalone";
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.typedArray / QByteArray", [
+    "Wraps the incoming TypedArray view as Uint8Array(value.buffer, value.byteOffset, value.byteLength) so only the visible bytes are emitted.",
+    "Wire format is identical to the buffer codec: one standalone base93 string carrying raw bytes.",
+    "C++ treats QByteArray as an opaque byte buffer and copies its bytes into the shared base93 encoder."
+]);
+exports.encoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${strategyComment}\n\n${(0, rawbytes_1.emitTsRawByteStandaloneEncoder)(TS_FN, "new Uint8Array(value.buffer, value.byteOffset, value.byteLength)")}`;
+    },
+    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()) + static_cast<std::size_t>(value.size()))")}`;
+    }
+};

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

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * AnQstGen base-type codec emitter for `binary-uint16Array`.
+ * Decoder consumes one base93 string of raw bytes and reconstructs a concrete `Uint16Array`.
+ * 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 = "decodeBinaryUint16ArrayStandalone";
+const CPP_FN = "decodeBinaryUint16ArrayStandalone";
+exports.decoder = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return [
+            (0, comments_1.emitStrategyComment)("AnQst Uint16Array decoder (raw-byte base93)", [
+                "Decodes base93 to bytes, then constructs a concrete Uint16Array over the decoded buffer.",
+                "Rejected odd decoded byte counts indicate corrupted wire data because Uint16Array elements require 2 bytes each."
+            ]),
+            `function ${TS_FN}(encoded) {`,
+            "  const bytes = base93Decode(encoded);",
+            "  if ((bytes.byteLength & 1) !== 0) {",
+            "    throw new RangeError(\"Decoded Uint16Array byte length must be divisible by 2.\");",
+            "  }",
+            "  return new Uint16Array(bytes.buffer);",
+            "}"
+        ].join("\n");
+    },
+    emitCppDecoder() {
+        return [
+            (0, comments_1.emitStrategyComment)("AnQst Uint16Array 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-uint16Array/encoder.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * AnQstGen base-type codec emitter for `binary-uint16Array`.
+ * Wire form is one base93 string carrying the raw bytes of a `Uint16Array` 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-uint16Array",
+    specPath: "RefinedSpecs/Codecs/Binary_uint16Array_Codec.md",
+    tsType: "Uint16Array",
+    cppType: "QByteArray",
+    wireCategory: "binary",
+    strategySummary: "Base93-encode the raw bytes of the Uint16Array view (respecting byteOffset/byteLength); C++ receives the same raw bytes in QByteArray."
+};
+const TS_FN = "encodeBinaryUint16ArrayStandalone";
+const CPP_FN = "encodeBinaryUint16ArrayStandalone";
+exports.encoder = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return [
+            (0, comments_1.emitStrategyComment)("AnQst Uint16Array encoder (raw-byte base93)", [
+                "Reads only the concrete view window via byteOffset/byteLength, so subviews do not leak adjacent buffer bytes.",
+                "Preserves platform-native endianness by forwarding the raw stored 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 Uint16Array 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");
+    }
+};