@dusted/anqst 1.5.0 → 1.5.1

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

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

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

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

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

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

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

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

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

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

@@ -1,49 +0,0 @@
-"use strict";
-/**
- * AnQstGen base-type codec emitter for `binary-uint32Array`.
- * Wire form is one base93 string carrying the raw bytes of a `Uint32Array` 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-uint32Array",
-    specPath: "RefinedSpecs/Codecs/Binary_uint32Array_Codec.md",
-    tsType: "Uint32Array",
-    cppType: "QByteArray",
-    wireCategory: "binary",
-    strategySummary: "Base93-encode the raw bytes of the Uint32Array view (respecting byteOffset/byteLength); C++ receives the same raw bytes in QByteArray."
-};
-const TS_FN = "encodeBinaryUint32ArrayStandalone";
-const CPP_FN = "encodeBinaryUint32ArrayStandalone";
-exports.encoder = {
-    descriptor: exports.descriptor,
-    emitTsEncoder() {
-        return [
-            (0, comments_1.emitStrategyComment)("AnQst Uint32Array 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 Uint32Array 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-uint8Array/decoder.js

@@ -1,28 +0,0 @@
-"use strict";
-/**
- * Base codec emitter: `AnQst.Type.uint8Array` decoder.
- * Reconstructs the standalone raw-byte base93 payload directly as a concrete `Uint8Array`
- * and mirrors the QByteArray interop contract used by the buffer codec.
- */
-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 = "decodeBinaryUint8ArrayStandalone";
-const CPP_FN = "decodeBinaryUint8ArrayStandalone";
-const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (decode): AnQst.Type.uint8Array / QByteArray", [
-    "Base93-decodes the standalone wire payload back to raw bytes with no structural wrapper.",
-    "TypeScript returns the Uint8Array produced by base93Decode directly; no ArrayBuffer extraction or reinterpretation.",
-    "C++ rebuilds a QByteArray from the decoded bytes for symmetry with the buffer codec's QByteArray mapping."
-]);
-exports.decoderEmitter = {
-    descriptor: encoder_1.descriptor,
-    emitTsDecoder() {
-        return `${strategyComment}\n\n${(0, rawbytes_1.emitTsRawByteStandaloneDecoder)(TS_FN, "bytes")}`;
-    },
-    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-uint8Array/encoder.js

@@ -1,34 +0,0 @@
-"use strict";
-/**
- * Base codec emitter: `AnQst.Type.uint8Array` encoder.
- * Emits standalone raw-byte base93 for concrete `Uint8Array` values and mirrors the
- * same wire contract as `AnQst.Type.buffer`, but keeps the TypeScript domain type concrete.
- */
-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-uint8Array",
-    specPath: "RefinedSpecs/Codecs/Binary_uint8Array_Codec.md",
-    tsType: "Uint8Array",
-    cppType: "QByteArray",
-    wireCategory: "binary",
-    strategySummary: "Encode the concrete Uint8Array byte view as standalone base93 raw bytes; preserves offset views by encoding only the visible window."
-};
-const TS_FN = "encodeBinaryUint8ArrayStandalone";
-const CPP_FN = "encodeBinaryUint8ArrayStandalone";
-const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.uint8Array / QByteArray", [
-    "Standalone wire is the standard raw-byte base93 string used for AnQst binary codecs.",
-    "TypeScript re-wraps the incoming Uint8Array with its byteOffset/byteLength so subarray views encode only the visible 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/boolean/decoder.js

@@ -1,34 +0,0 @@
-"use strict";
-/**
- * Boolean wire codec (decoder side)
- *
- * Strategy:
- * - Read the raw JSON-safe wire strings `"0"` / `"1"` directly.
- * - `"1"` → true; anything else → false (no JavaScript truthiness for non-boolean inputs).
- * - C++ compares the incoming string to `"1"`.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decoder = exports.descriptor = void 0;
-const encoder_1 = require("./encoder");
-Object.defineProperty(exports, "descriptor", { enumerable: true, get: function () { return encoder_1.descriptor; } });
-const TS_DECODE_FN = "decodeBoolean";
-const CPP_DECODE_FN = "decodeBoolean";
-function emitTsDecoderSource() {
-    return `function ${TS_DECODE_FN}(encoded) {
-  return encoded === "1";
-}`;
-}
-function emitCppDecoderSource() {
-    return `inline bool ${CPP_DECODE_FN}(const std::string& encoded) {
-  return encoded == "1";
-}`;
-}
-exports.decoder = {
-    descriptor: encoder_1.descriptor,
-    emitTsDecoder() {
-        return emitTsDecoderSource();
-    },
-    emitCppDecoder() {
-        return emitCppDecoderSource();
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/boolean/encoder.js

@@ -1,40 +0,0 @@
-"use strict";
-/**
- * Boolean wire codec (encoder side)
- *
- * Strategy:
- * - Map `false`/`true` to the raw JSON-safe strings `"0"` / `"1"`.
- * - Avoid byte packing and base93 overhead for a two-state value that already fits in one character.
- * - Emitted helpers produce wire strings directly.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encoder = exports.descriptor = void 0;
-const TS_ENCODE_FN = "encodeBoolean";
-const CPP_ENCODE_FN = "encodeBoolean";
-exports.descriptor = {
-    codecId: "boolean",
-    specPath: "RefinedSpecs/Codecs/Boolean_boolean_Codec.md",
-    tsType: "boolean",
-    cppType: "bool",
-    wireCategory: "string",
-    strategySummary: 'Single-character wire strings "0"/"1" for false/true; not JSON boolean; no bit packing.'
-};
-function emitTsEncoderSource() {
-    return `function ${TS_ENCODE_FN}(value) {
-  return value ? "1" : "0";
-}`;
-}
-function emitCppEncoderSource() {
-    return `inline std::string ${CPP_ENCODE_FN}(bool value) {
-  return value ? "1" : "0";
-}`;
-}
-exports.encoder = {
-    descriptor: exports.descriptor,
-    emitTsEncoder() {
-        return emitTsEncoderSource();
-    },
-    emitCppEncoder() {
-        return emitCppEncoderSource();
-    }
-};

package/dist/src/codecgenerators/basecodecemitters/dynamic-json/decoder.js

@@ -1,43 +0,0 @@
-"use strict";
-/**
- * AnQst base-type codec emitter: AnQst.Type.json (dynamic JSON object).
- *
- * Wire: parsed JSON Object is the domain value — identity decode, same as AnQst.Type.object
- * on the TS side. C++ decode maps QJsonValue → QJsonObject via toObject() without QVariantMap.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decoder = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-exports.descriptor = {
-    codecId: "AnQst.Type.json",
-    specPath: "RefinedSpecs/Codecs/Dynamic_json_Codec.md",
-    tsType: "object",
-    cppType: "QJsonObject",
-    wireCategory: "dynamic",
-    strategySummary: "Pass-through JSON Object on the wire (same as object); C++ domain is QJsonObject with direct QJsonValue interop (encode wrap, decode toObject)."
-};
-function emitTsDecoderSource(functionName = "decodeDynamicJson") {
-    const comment = (0, comments_1.emitStrategyComment)("AnQst.Type.json — TypeScript decode (identity)", [
-        "The JSON Object from the wire is the domain value; no per-field transform.",
-        "Applies where the spec names AnQst.Type.json; wire shape matches AnQst.Type.object."
-    ]);
-    return `${comment}
-function ${functionName}(wire) {
-  return wire;
-}`;
-}
-function emitCppDecoderSource(functionName = "decodeDynamicJsonFromJsonValue") {
-    const comment = (0, comments_1.emitStrategyComment)("AnQst.Type.json — C++ decode (QJsonValue → QJsonObject)", [
-        "Direct toObject() into QJsonObject — contrast AnQst.Type.object QVariantMap decode path.",
-        "Thin QJsonObject-oriented helper; Qt headers required to compile."
-    ]);
-    return `${comment}
-inline QJsonObject ${functionName}(const QJsonValue& value) {
-  return value.toObject();
-}`;
-}
-exports.decoder = {
-    descriptor: exports.descriptor,
-    emitTsDecoder: () => emitTsDecoderSource(),
-    emitCppDecoder: () => emitCppDecoderSource()
-};

package/dist/src/codecgenerators/basecodecemitters/dynamic-json/encoder.js

@@ -1,45 +0,0 @@
-"use strict";
-/**
- * AnQst base-type codec emitter: AnQst.Type.json (dynamic JSON object).
- *
- * Wire: identical to AnQst.Type.object — a native JSON Object, pass-through for
- * JSON.stringify / JSON.parse. Distinct only in descriptor and C++ mapping (QJsonObject
- * and direct QJsonValue interop, no QVariantMap). See Dynamic_json_Codec.md.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encoder = exports.descriptor = void 0;
-const comments_1 = require("../shared/comments");
-exports.descriptor = {
-    codecId: "AnQst.Type.json",
-    specPath: "RefinedSpecs/Codecs/Dynamic_json_Codec.md",
-    tsType: "object",
-    cppType: "QJsonObject",
-    wireCategory: "dynamic",
-    strategySummary: "Pass-through JSON Object on the wire (same as object); C++ domain is QJsonObject with direct QJsonValue interop (encode wrap, decode toObject)."
-};
-function emitTsEncoderSource(functionName = "encodeDynamicJson") {
-    const comment = (0, comments_1.emitStrategyComment)("AnQst.Type.json — TypeScript encode (identity on wire payload)", [
-        "Same wire behavior as AnQst.Type.object; distinct type metadata selects QJsonObject in generated C++.",
-        "The domain object is emitted as-is; JSON.stringify supplies JSON Object syntax.",
-        "Values must be JSON-serializable; non-JSON-native values fail at stringify time."
-    ]);
-    return `${comment}
-function ${functionName}(value) {
-  return value;
-}`;
-}
-function emitCppEncoderSource(functionName = "encodeDynamicJsonToJsonValue") {
-    const comment = (0, comments_1.emitStrategyComment)("AnQst.Type.json — C++ encode (QJsonObject → QJsonValue)", [
-        "QJsonObject is JSON-native in Qt; wrap directly for placement in QJsonValue — no QVariantMap hop.",
-        "Use only for explicit AnQst.Type.json; requires Qt JSON types in the translation unit."
-    ]);
-    return `${comment}
-inline QJsonValue ${functionName}(const QJsonObject& jsonObj) {
-  return QJsonValue(jsonObj);
-}`;
-}
-exports.encoder = {
-    descriptor: exports.descriptor,
-    emitTsEncoder: () => emitTsEncoderSource(),
-    emitCppEncoder: () => emitCppEncoderSource()
-};