@dusted/anqst 1.0.0 → 1.5.0

package/dist/src/codecgenerators/basecodecemitters/integer-qint16/decoder.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Base codec emitter: AnQst.Type.qint16 — TypeScript decoder (standalone base93 string → number).
+ *
+ * - Decodes base93 to 2 bytes, then reads signed 16-bit two's complement via Int16Array.
+ * - Returns the JavaScript number represented by that qint16 payload.
+ * - C++ side performs the same memcpy-based reinterpretation into qint16.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoderEmitter = exports.descriptor = void 0;
+const fixedwidth_1 = require("../shared/fixedwidth");
+const FIXED_WIDTH = {
+    byteWidth: 2,
+    tsViewCtor: "Int16Array",
+    cppType: "qint16"
+};
+exports.descriptor = {
+    codecId: "integer-qint16",
+    specPath: "RefinedSpecs/Codecs/Integer_qint16_Codec.md",
+    tsType: "number",
+    cppType: "qint16",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Decode standalone base93 to 2 bytes, reinterpret them as qint16 / Int16Array[0] and return the resulting number.",
+    fixedWidth: FIXED_WIDTH
+};
+const TS_FN = "decodeQint16Standalone";
+const CPP_FN = "decodeQint16Standalone";
+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/integer-qint16/encoder.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Base codec emitter: AnQst.Type.qint16 — TypeScript encoder (number → standalone base93 string).
+ *
+ * - 2-byte signed two's complement via Int16Array; platform-native byte order.
+ * - Standalone wire: one base93 string (3 characters for 2 bytes).
+ * - C++ side mirrors layout with memcpy into qint16, keeping TS/C++ interop portable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoderEmitter = exports.descriptor = void 0;
+const fixedwidth_1 = require("../shared/fixedwidth");
+const FIXED_WIDTH = {
+    byteWidth: 2,
+    tsViewCtor: "Int16Array",
+    cppType: "qint16"
+};
+exports.descriptor = {
+    codecId: "integer-qint16",
+    specPath: "RefinedSpecs/Codecs/Integer_qint16_Codec.md",
+    tsType: "number",
+    cppType: "qint16",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Serialize qint16 as 2-byte signed two's complement (Int16Array / C++ memcpy), then base93-encode to a standalone JSON string.",
+    fixedWidth: FIXED_WIDTH
+};
+const TS_FN = "encodeQint16Standalone";
+const CPP_FN = "encodeQint16Standalone";
+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/integer-qint32/decoder.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Base codec emitter: AnQst.Type.qint32 — TypeScript decoder (standalone base93 string → number).
+ *
+ * - Decodes base93 to 4 bytes, then reads signed 32-bit two's complement via Int32Array.
+ * - Returns the JavaScript number represented by that qint32 payload.
+ * - C++ side performs the same 4-byte reinterpretation with memcpy into qint32.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoderEmitter = 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 FIXED_WIDTH = encoder_1.descriptor.fixedWidth;
+const TS_FN = "decodeQint32Standalone";
+const CPP_FN = "decodeQint32Standalone";
+exports.decoderEmitter = {
+    descriptor: encoder_1.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/integer-qint32/encoder.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Base codec emitter: AnQst.Type.qint32 — TypeScript encoder (number → standalone base93 string).
+ *
+ * - 4-byte signed two's complement via Int32Array; platform-native byte order.
+ * - Standalone wire: one base93 string (5 characters for 4 bytes).
+ * - C++ side mirrors the same 4-byte layout with memcpy into qint32.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoderEmitter = exports.descriptor = void 0;
+const fixedwidth_1 = require("../shared/fixedwidth");
+const FIXED_WIDTH = {
+    byteWidth: 4,
+    tsViewCtor: "Int32Array",
+    cppType: "qint32"
+};
+exports.descriptor = {
+    codecId: "integer-qint32",
+    specPath: "RefinedSpecs/Codecs/Integer_qint32_Codec.md",
+    tsType: "number",
+    cppType: "qint32",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Serialize qint32 as 4-byte signed two's complement (Int32Array / C++ memcpy), then base93-encode to a standalone 5-character JSON string.",
+    fixedWidth: FIXED_WIDTH
+};
+const TS_FN = "encodeQint32Standalone";
+const CPP_FN = "encodeQint32Standalone";
+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/integer-qint8/decoder.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Base codec emitter: AnQst.Type.qint8 — TypeScript decoder (standalone base93 string → number).
+ *
+ * - Decodes base93 to 1 byte, then reads signed 8-bit two's complement via Int8Array.
+ * - Returns the JavaScript number represented by that single signed byte.
+ * - C++ side performs the same single-byte reinterpretation, which is portable for qint8.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoderEmitter = exports.descriptor = void 0;
+const fixedwidth_1 = require("../shared/fixedwidth");
+const FIXED_WIDTH = {
+    byteWidth: 1,
+    tsViewCtor: "Int8Array",
+    cppType: "qint8"
+};
+exports.descriptor = {
+    codecId: "integer-qint8",
+    specPath: "RefinedSpecs/Codecs/Integer_qint8_Codec.md",
+    tsType: "number",
+    cppType: "qint8",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Decode standalone base93 to 1 byte, reinterpret it as qint8 / Int8Array[0] and return the resulting number.",
+    fixedWidth: FIXED_WIDTH
+};
+const TS_FN = "decodeQint8Standalone";
+const CPP_FN = "decodeQint8Standalone";
+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/integer-qint8/encoder.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Base codec emitter: AnQst.Type.qint8 — TypeScript encoder (number → standalone base93 string).
+ *
+ * - 1-byte signed two's complement via Int8Array; no runtime range/type validation.
+ * - Standalone wire: one base93 string (2 characters for 1 byte).
+ * - C++ side mirrors the same single-byte layout, so interoperability is portable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoderEmitter = exports.descriptor = void 0;
+const fixedwidth_1 = require("../shared/fixedwidth");
+const FIXED_WIDTH = {
+    byteWidth: 1,
+    tsViewCtor: "Int8Array",
+    cppType: "qint8"
+};
+exports.descriptor = {
+    codecId: "integer-qint8",
+    specPath: "RefinedSpecs/Codecs/Integer_qint8_Codec.md",
+    tsType: "number",
+    cppType: "qint8",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Serialize qint8 as 1-byte signed two's complement (Int8Array / single C++ byte), then base93-encode to a standalone JSON string.",
+    fixedWidth: FIXED_WIDTH
+};
+const TS_FN = "encodeQint8Standalone";
+const CPP_FN = "encodeQint8Standalone";
+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/integer-quint16/decoder.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Base codec emitter (decode): base93 blob → TypeScript `number`, C++ `quint16`.
+ * Reconstructs the platform-native 2-byte unsigned scalar from a 3-character base93 payload.
+ * See RefinedSpecs/Codecs/Integer_quint16_Codec.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+const fixedwidth_1 = require("../shared/fixedwidth");
+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.quint16 / quint16", [
+    "Decodes base93 to exactly 2 bytes, then reads Uint16Array[0] in TypeScript or quint16 in C++.",
+    "Standalone payloads are fixed-width and therefore always 3 base93 characters for valid quint16 values.",
+    "Portable interoperability is byte-exact because both sides reinterpret the same 2 decoded bytes as quint16."
+]);
+exports.decoderEmitter = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneDecoder)("decodeQuint16Standalone", encoder_1.descriptor.fixedWidth)}`;
+    },
+    emitCppDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneDecoder)("decodeQuint16Standalone", encoder_1.descriptor.fixedWidth)}`;
+    }
+};

package/dist/src/codecgenerators/basecodecemitters/integer-quint16/encoder.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Base codec emitter (encode): AnQst.Type.quint16 ↔ TypeScript `number`, C++ `quint16`.
+ * Standalone wire shape is one 3-character base93 string carrying exactly 2 raw bytes.
+ * See RefinedSpecs/Codecs/Integer_quint16_Codec.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+const fixedwidth_1 = require("../shared/fixedwidth");
+const FIXED_WIDTH = {
+    byteWidth: 2,
+    tsViewCtor: "Uint16Array",
+    cppType: "quint16"
+};
+exports.descriptor = {
+    codecId: "integer-quint16",
+    specPath: "RefinedSpecs/Codecs/Integer_quint16_Codec.md",
+    tsType: "number",
+    cppType: "quint16",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Unsigned 16-bit scalar: write the platform-native 2-byte Uint16Array/quint16 representation, then base93-encode it to a 3-character standalone string.",
+    fixedWidth: FIXED_WIDTH
+};
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.quint16 / quint16", [
+    "Uses Uint16Array[0] so TypeScript follows the quint16 prose for the host-native 2-byte unsigned representation.",
+    "Emits exactly 3 base93 characters for the standalone wire payload because 2 raw bytes are encoded directly.",
+    "C++ encoder memcpy-copies the same 2 bytes from quint16, preserving portable interop at the byte level."
+]);
+exports.encoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)("encodeQuint16Standalone", FIXED_WIDTH)}`;
+    },
+    emitCppEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)("encodeQuint16Standalone", FIXED_WIDTH)}`;
+    }
+};

package/dist/src/codecgenerators/basecodecemitters/integer-quint32/decoder.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Base codec emitter (decode): base93 blob → TypeScript `number`, C++ `quint32`.
+ * Reconstructs the 4-byte unsigned payload from a 5-character base93 string and
+ * reads it back through Uint32Array / quint32 in host-native byte order.
+ * See RefinedSpecs/Codecs/Integer_quint32_Codec.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+const fixedwidth_1 = require("../shared/fixedwidth");
+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.quint32 / quint32", [
+    "Decodes base93 to 4 bytes, then reads Uint32Array[0] in TypeScript or quint32 in C++.",
+    "Standalone payloads are fixed-width and therefore always 5 base93 characters for valid quint32 values.",
+    "Portable interoperability is direct because both sides reinterpret the same 4 decoded bytes."
+]);
+exports.decoderEmitter = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneDecoder)("decodeQuint32Standalone", encoder_1.descriptor.fixedWidth)}`;
+    },
+    emitCppDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneDecoder)("decodeQuint32Standalone", encoder_1.descriptor.fixedWidth)}`;
+    }
+};

package/dist/src/codecgenerators/basecodecemitters/integer-quint32/encoder.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Base codec emitter (encode): AnQst.Type.quint32 ↔ TypeScript `number`, C++ `quint32`.
+ * Standalone wire shape is one 5-character base93 string carrying exactly 4 bytes
+ * from a Uint32Array host-native unsigned 32-bit representation.
+ * See RefinedSpecs/Codecs/Integer_quint32_Codec.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+const fixedwidth_1 = require("../shared/fixedwidth");
+const FIXED_WIDTH = {
+    byteWidth: 4,
+    tsViewCtor: "Uint32Array",
+    cppType: "quint32"
+};
+exports.descriptor = {
+    codecId: "integer-quint32",
+    specPath: "RefinedSpecs/Codecs/Integer_quint32_Codec.md",
+    tsType: "number",
+    cppType: "quint32",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Unsigned 32-bit scalar: materialize 4 host-native bytes via Uint32Array/quint32, then base93-encode them to a standalone 5-character string.",
+    fixedWidth: FIXED_WIDTH
+};
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.quint32 / quint32", [
+    "Uses Uint32Array[0] so TypeScript follows the quint32 prose for 4-byte unsigned materialization.",
+    "Emits exactly 5 base93 characters for the standalone wire payload.",
+    "C++ encoder memcpy-copies the quint32 bytes, matching the TypeScript wire byte-for-byte on the same host."
+]);
+exports.encoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)("encodeQuint32Standalone", FIXED_WIDTH)}`;
+    },
+    emitCppEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)("encodeQuint32Standalone", FIXED_WIDTH)}`;
+    }
+};

package/dist/src/codecgenerators/basecodecemitters/integer-quint8/decoder.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Base codec emitter (decode): base93 blob → TypeScript `number`, C++ `quint8`.
+ * Reconstructs the single unsigned byte from a 2-character base93 payload.
+ * See RefinedSpecs/Codecs/Integer_quint8_Codec.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+const fixedwidth_1 = require("../shared/fixedwidth");
+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.quint8 / quint8", [
+    "Decodes base93 to one byte, then reads Uint8Array[0] in TypeScript or quint8 in C++.",
+    "Standalone payloads are fixed-width and therefore always 2 base93 characters for valid quint8 values.",
+    "Portable interoperability is direct because the byte itself is already the decoded unsigned 8-bit value."
+]);
+exports.decoderEmitter = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneDecoder)("decodeQuint8Standalone", encoder_1.descriptor.fixedWidth)}`;
+    },
+    emitCppDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneDecoder)("decodeQuint8Standalone", encoder_1.descriptor.fixedWidth)}`;
+    }
+};

package/dist/src/codecgenerators/basecodecemitters/integer-quint8/encoder.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Base codec emitter (encode): AnQst.Type.quint8 ↔ TypeScript `number`, C++ `quint8`.
+ * Standalone wire shape is one 2-character base93 string carrying exactly 1 byte.
+ * See RefinedSpecs/Codecs/Integer_quint8_Codec.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+const fixedwidth_1 = require("../shared/fixedwidth");
+const FIXED_WIDTH = {
+    byteWidth: 1,
+    tsViewCtor: "Uint8Array",
+    cppType: "quint8"
+};
+exports.descriptor = {
+    codecId: "integer-quint8",
+    specPath: "RefinedSpecs/Codecs/Integer_quint8_Codec.md",
+    tsType: "number",
+    cppType: "quint8",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Unsigned 8-bit scalar: write the low 8 bits via Uint8Array/quint8, then base93-encode the single byte to a 2-character standalone string.",
+    fixedWidth: FIXED_WIDTH
+};
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.quint8 / quint8", [
+    "Uses Uint8Array[0] so TypeScript follows the quint8 prose for 1-byte unsigned truncation/wrapping.",
+    "Emits exactly 2 base93 characters for the standalone wire payload.",
+    "C++ encoder memcpy-copies the single quint8 byte, matching the TypeScript wire byte-for-byte."
+]);
+exports.encoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)("encodeQuint8Standalone", FIXED_WIDTH)}`;
+    },
+    emitCppEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)("encodeQuint8Standalone", FIXED_WIDTH)}`;
+    }
+};

package/dist/src/codecgenerators/basecodecemitters/integer-uint16/decoder.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Base codec emitter (decode): base93 blob -> TypeScript `number`, C++ `uint16_t`.
+ *
+ * This reverses the standalone `uint16` encoder by decoding 3 base93 characters
+ * to 2 bytes and reading them through `Uint16Array` / `uint16_t`. The wire
+ * contract is intentionally identical to `quint16`, while descriptor identity
+ * remains distinct for downstream code generation and C++ type selection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+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 strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (decode): AnQst.Type.uint16 / uint16_t", [
+    "Base93-decodes the standalone payload to 2 bytes, then reads them through Uint16Array or uint16_t.",
+    "Returns the JavaScript number represented by the unsigned 16-bit host-endian byte pair.",
+    "Accepts the same 3-character wires as quint16 because the byte-level wire format is deliberately identical."
+]);
+exports.decoderEmitter = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneDecoder)("decodeUint16Standalone", fixedWidth)}`;
+    },
+    emitCppDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneDecoder)("decodeUint16Standalone", fixedWidth)}`;
+    }
+};

package/dist/src/codecgenerators/basecodecemitters/integer-uint16/encoder.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Base codec emitter (encode): `AnQst.Type.uint16` -> TypeScript `number`, C++ `uint16_t`.
+ *
+ * This codec is wire-identical to `AnQst.Type.quint16`: a fixed-width unsigned
+ * 16-bit scalar written through `Uint16Array`, preserving the platform-native
+ * 2-byte layout before base93-encoding it to a 3-character standalone string.
+ * The distinction is preserved only in descriptor metadata and emitted C++
+ * mapping (`uint16_t` instead of `quint16`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+const fixedwidth_1 = require("../shared/fixedwidth");
+const fixedWidth = {
+    byteWidth: 2,
+    tsViewCtor: "Uint16Array",
+    cppType: "uint16_t"
+};
+exports.descriptor = {
+    codecId: "AnQst.Type.uint16",
+    specPath: "RefinedSpecs/Codecs/Integer_uint16_Codec.md",
+    tsType: "number",
+    cppType: "uint16_t",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Wire-identical to quint16: 2-byte unsigned scalar via Uint16Array / memcpy into uint16_t, base93-encoded as a 3-character standalone string.",
+    fixedWidth
+};
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.uint16 / uint16_t", [
+    "Uses Uint16Array so TypeScript follows the uint16/quint16 prose for unsigned 16-bit host-endian bytes.",
+    "Emits exactly 3 base93 characters because the standalone payload is always 2 bytes wide.",
+    "C++ encoder memcpy-copies uint16_t into the same 2-byte payload, keeping the wire identical to quint16."
+]);
+exports.encoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)("encodeUint16Standalone", fixedWidth)}`;
+    },
+    emitCppEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)("encodeUint16Standalone", fixedWidth)}`;
+    }
+};

package/dist/src/codecgenerators/basecodecemitters/integer-uint32/decoder.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Base codec emitter (decode): base93 blob -> TypeScript `number`, C++ `uint32_t`.
+ *
+ * This reverses the standalone `uint32` encoder by decoding 5 base93 characters
+ * to 4 bytes and reading them through `Uint32Array` / `uint32_t`. The wire
+ * contract is intentionally identical to `quint32`, while descriptor identity
+ * remains distinct for downstream code generation and C++ type selection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoder = exports.decoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+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 strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (decode): AnQst.Type.uint32 / uint32_t", [
+    "Base93-decodes the standalone payload to 4 bytes, then reads them through Uint32Array or uint32_t.",
+    "Returns the JavaScript number represented by the unsigned 32-bit host-endian byte sequence.",
+    "Accepts the same 5-character wires as quint32 because the byte-level wire format is deliberately identical."
+]);
+exports.decoderEmitter = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneDecoder)("decodeUint32Standalone", fixedWidth)}`;
+    },
+    emitCppDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneDecoder)("decodeUint32Standalone", fixedWidth)}`;
+    }
+};
+exports.decoder = exports.decoderEmitter;

package/dist/src/codecgenerators/basecodecemitters/integer-uint32/encoder.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Base codec emitter (encode): `AnQst.Type.uint32` -> TypeScript `number`, C++ `uint32_t`.
+ *
+ * This codec is wire-identical to `AnQst.Type.quint32`: a fixed-width unsigned
+ * 32-bit scalar written through `Uint32Array`, preserving the platform-native
+ * 4-byte layout before base93-encoding it to a 5-character standalone string.
+ * The distinction is preserved only in descriptor metadata and emitted C++
+ * mapping (`uint32_t` instead of `quint32`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoder = exports.encoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+const fixedwidth_1 = require("../shared/fixedwidth");
+const fixedWidth = {
+    byteWidth: 4,
+    tsViewCtor: "Uint32Array",
+    cppType: "uint32_t"
+};
+exports.descriptor = {
+    codecId: "AnQst.Type.uint32",
+    specPath: "RefinedSpecs/Codecs/Integer_uint32_Codec.md",
+    tsType: "number",
+    cppType: "uint32_t",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Wire-identical to quint32: 4-byte unsigned scalar via Uint32Array / memcpy into uint32_t, base93-encoded as a 5-character standalone string.",
+    fixedWidth
+};
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.uint32 / uint32_t", [
+    "Uses Uint32Array so TypeScript follows the uint32/quint32 prose for unsigned 32-bit host-endian bytes.",
+    "Emits exactly 5 base93 characters because the standalone payload is always 4 bytes wide.",
+    "C++ encoder memcpy-copies uint32_t into the same 4-byte payload, keeping the wire identical to quint32."
+]);
+exports.encoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)("encodeUint32Standalone", fixedWidth)}`;
+    },
+    emitCppEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)("encodeUint32Standalone", fixedWidth)}`;
+    }
+};
+exports.encoder = exports.encoderEmitter;

package/dist/src/codecgenerators/basecodecemitters/integer-uint8/decoder.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Base codec emitter (decode): base93 blob -> TypeScript `number`, C++ `uint8_t`.
+ *
+ * This reverses the standalone `uint8` encoder by decoding 2 base93 characters
+ * to one byte and reading that byte through `Uint8Array` / `uint8_t`. The wire
+ * contract is identical to `quint8`, while the descriptor keeps the `uint8_t`
+ * identity for downstream code generation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoder = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+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 strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (decode): AnQst.Type.uint8 / uint8_t", [
+    "Base93-decodes the standalone payload to one byte, then reads it through Uint8Array or uint8_t.",
+    "Returns a JS number in the unsigned 0-255 domain described by the uint8 spec.",
+    "Accepts the same 2-character wire strings as quint8 because the wire format is intentionally identical."
+]);
+exports.decoder = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneDecoder)("decodeUint8Standalone", fixedWidth)}`;
+    },
+    emitCppDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneDecoder)("decodeUint8Standalone", fixedWidth)}`;
+    }
+};

package/dist/src/codecgenerators/basecodecemitters/integer-uint8/encoder.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Base codec emitter (encode): `AnQst.Type.uint8` -> TypeScript `number`, C++ `uint8_t`.
+ *
+ * This codec is wire-identical to `AnQst.Type.quint8`: a single unsigned byte
+ * encoded as a 2-character base93 string. The distinction is preserved only in
+ * descriptor metadata and the emitted C++ type mapping (`uint8_t` vs `quint8`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoder = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+const fixedwidth_1 = require("../shared/fixedwidth");
+const fixedWidth = {
+    byteWidth: 1,
+    tsViewCtor: "Uint8Array",
+    cppType: "uint8_t"
+};
+exports.descriptor = {
+    codecId: "AnQst.Type.uint8",
+    specPath: "RefinedSpecs/Codecs/Integer_uint8_Codec.md",
+    tsType: "number",
+    cppType: "uint8_t",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Single unsigned byte via Uint8Array / memcpy into uint8_t, base93 standalone string (2 chars); wire-identical to quint8 but descriptor/C++ mapping remain distinct.",
+    fixedWidth
+};
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.uint8 / uint8_t", [
+    "Uses Uint8Array for the 1-byte unsigned representation on the TS side.",
+    "Uses std::memcpy into uint8_t on the C++ side for the same single-byte payload.",
+    "Produces the same 2-character base93 wire form as quint8; only descriptor and C++ typedef mapping differ."
+]);
+exports.encoder = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)("encodeUint8Standalone", fixedWidth)}`;
+    },
+    emitCppEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)("encodeUint8Standalone", fixedWidth)}`;
+    }
+};