@dusted/anqst 1.0.1 → 1.5.0

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)}`;
+    }
+};

package/dist/src/codecgenerators/basecodecemitters/number/decoder.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Base codec emitter (decode): base93 blob → TypeScript `number`, C++ `double`.
+ * Reconstructs IEEE 754 binary64 from eight decoded bytes (platform-native order).
+ * See RefinedSpecs/Codecs/Number_number_Codec.md and AnQst-Opaque-Wire-Contract.md §6.4.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberDecoderEmitter = 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.number / double", [
+    "Decodes base93 to bytes, then Float64Array (TS) or std::memcpy (C++).",
+    "Expects base93Decode in scope; standalone payloads are exactly 10 characters.",
+    "Round-trips all IEEE special values and distinct NaN payloads when produced by the encoder."
+]);
+exports.numberDecoderEmitter = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneDecoder)("decodeAnQstNumber", encoder_1.descriptor.fixedWidth)}`;
+    },
+    emitCppDecoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneDecoder)("decodeAnQstNumber", encoder_1.descriptor.fixedWidth)}`;
+    }
+};

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

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Base codec emitter (encode): AnQst.Type.number ↔ TypeScript `number`, C++ `double`.
+ * Standalone wire shape is one base93 string of length 10 (8 IEEE 754 binary64 bytes).
+ * See RefinedSpecs/Codecs/Number_number_Codec.md and AnQst-Codec-Design-Principles.md §4.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberEncoderEmitter = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+const fixedwidth_1 = require("../shared/fixedwidth");
+const fixedWidth = {
+    byteWidth: 8,
+    tsViewCtor: "Float64Array",
+    cppType: "double"
+};
+exports.descriptor = {
+    codecId: "AnQst.Type.number",
+    specPath: "RefinedSpecs/Codecs/Number_number_Codec.md",
+    tsType: "number",
+    cppType: "double",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "IEEE 754 binary64: 8 platform-native bytes packed via base93 (10 characters standalone).",
+    fixedWidth
+};
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.number / double", [
+    "Uses Float64Array (TS) or std::memcpy (C++) for platform-native IEEE 754 bytes.",
+    "Emits base93 via shared fixed-width standalone helper (expects base93Encode in scope).",
+    "Preserves all bit patterns including ±0, NaN, ±Infinity, subnormals."
+]);
+exports.numberEncoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)("encodeAnQstNumber", fixedWidth)}`;
+    },
+    emitCppEncoder() {
+        return `${strategyComment}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)("encodeAnQstNumber", fixedWidth)}`;
+    }
+};

package/dist/src/codecgenerators/basecodecemitters/shared/comments.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitStrategyComment = emitStrategyComment;
+function emitStrategyComment(title, bullets) {
+    const lines = [
+        "/**",
+        ` * ${title}`,
+        " *",
+        ...bullets.map((bullet) => ` * - ${bullet}`),
+        " */"
+    ];
+    return lines.join("\n");
+}

package/dist/src/codecgenerators/basecodecemitters/shared/contracts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/codecgenerators/basecodecemitters/shared/fixedwidth.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitTsFixedWidthStandaloneEncoder = emitTsFixedWidthStandaloneEncoder;
+exports.emitTsFixedWidthStandaloneDecoder = emitTsFixedWidthStandaloneDecoder;
+exports.emitCppFixedWidthStandaloneEncoder = emitCppFixedWidthStandaloneEncoder;
+exports.emitCppFixedWidthStandaloneDecoder = emitCppFixedWidthStandaloneDecoder;
+function tsScalarBufferInit(descriptor, valueExpr) {
+    return [
+        `const buf = new ArrayBuffer(${descriptor.byteWidth});`,
+        `new ${descriptor.tsViewCtor}(buf)[0] = ${valueExpr};`,
+        "const bytes = new Uint8Array(buf);"
+    ];
+}
+function tsScalarBufferRead(descriptor, bytesExpr) {
+    return [
+        `const buf = new ArrayBuffer(${descriptor.byteWidth});`,
+        `new Uint8Array(buf).set(${bytesExpr});`,
+        `return new ${descriptor.tsViewCtor}(buf)[0];`
+    ];
+}
+function emitTsFixedWidthStandaloneEncoder(functionName, descriptor, valueExpr = "value") {
+    const lines = [
+        `function ${functionName}(value) {`,
+        ...tsScalarBufferInit(descriptor, valueExpr).map((line) => `  ${line}`),
+        "  return base93Encode(bytes);",
+        "}"
+    ];
+    return lines.join("\n");
+}
+function emitTsFixedWidthStandaloneDecoder(functionName, descriptor) {
+    const lines = [
+        `function ${functionName}(encoded) {`,
+        "  const bytes = base93Decode(encoded);",
+        ...tsScalarBufferRead(descriptor, "bytes").map((line) => `  ${line}`),
+        "}"
+    ];
+    return lines.join("\n");
+}
+function emitCppFixedWidthStandaloneEncoder(functionName, descriptor) {
+    return `inline std::string ${functionName}(const ${descriptor.cppType}& value) {
+  std::array<std::uint8_t, ${descriptor.byteWidth}> bytes{};
+  std::memcpy(bytes.data(), &value, ${descriptor.byteWidth});
+  return base93Encode(std::vector<std::uint8_t>(bytes.begin(), bytes.end()));
+}`;
+}
+function emitCppFixedWidthStandaloneDecoder(functionName, descriptor) {
+    return `inline ${descriptor.cppType} ${functionName}(const std::string& encoded) {
+  const std::vector<std::uint8_t> bytes = base93Decode(encoded);
+  ${descriptor.cppType} value{};
+  std::memcpy(&value, bytes.data(), ${descriptor.byteWidth});
+  return value;
+}`;
+}

package/dist/src/codecgenerators/basecodecemitters/shared/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./comments"), exports);
+__exportStar(require("./contracts"), exports);
+__exportStar(require("./fixedwidth"), exports);
+__exportStar(require("./positionalBase93"), exports);
+__exportStar(require("./rawbytes"), exports);

package/dist/src/codecgenerators/basecodecemitters/shared/positionalBase93.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitPositionalBase93CountEncoder = emitPositionalBase93CountEncoder;
+exports.emitPositionalBase93CountDecoder = emitPositionalBase93CountDecoder;
+exports.emitPositionalBase93CountCppFunctions = emitPositionalBase93CountCppFunctions;
+const base93_1 = require("../../../base93");
+function emitPositionalBase93CountEncoder(functionName = "encodeBase93Count") {
+    return `function ${functionName}(value) {
+var A = "${base93_1.BASE93_ALPHABET}", v = value >>> 0, out = "";
+if (v === 0) return A[0];
+while (v > 0) {
+  out = A[v % 93] + out;
+  v = (v / 93) | 0;
+}
+return out;
+}`;
+}
+function emitPositionalBase93CountDecoder(functionName = "decodeBase93Count") {
+    return `function ${functionName}(value) {
+var n = value.length, acc = 0, i, c;
+for (i = 0; i < n; i++) {
+  c = value.charCodeAt(i);
+  acc = acc * 93 + c - 32 - (c > 34) - (c > 92);
+}
+return acc >>> 0;
+}`;
+}
+function emitPositionalBase93CountCppFunctions() {
+    return `inline std::string encodeBase93Count(std::uint32_t value) {
+  static constexpr char A[] = "${base93_1.BASE93_ALPHABET}";
+  if (value == 0u) return std::string(1, A[0]);
+  std::string out;
+  while (value > 0u) {
+    out.insert(out.begin(), A[value % 93u]);
+    value /= 93u;
+  }
+  return out;
+}
+
+inline std::uint32_t decodeBase93Count(const std::string& value) {
+  std::uint32_t acc = 0;
+  for (char c : value) {
+    const unsigned char uc = static_cast<unsigned char>(c);
+    acc = acc * 93u + static_cast<std::uint32_t>(uc - 32 - (uc > 34) - (uc > 92));
+  }
+  return acc;
+}`;
+}