@dusted/anqst 1.0.0 → 1.5.0

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * AnQst base-type codec emitter: AnQst.Type.object (dynamic object).
+ *
+ * Wire: parsed JSON Object is the domain value — identity decode. Same scope rules as the
+ * encoder: only for explicitly declared dynamic object types in the spec, never as a generic
+ * fallback for unknown static shapes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoder = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+exports.descriptor = {
+    codecId: "AnQst.Type.object",
+    specPath: "RefinedSpecs/Codecs/Dynamic_object_Codec.md",
+    tsType: "object",
+    cppType: "QVariantMap",
+    wireCategory: "dynamic",
+    strategySummary: "Pass-through JSON Object on the wire for explicitly dynamic AnQst.Type.object only; no base93, no flattening."
+};
+function emitTsDecoderSource(functionName = "decodeDynamicObject") {
+    const comment = (0, comments_1.emitStrategyComment)("AnQst.Type.object — TypeScript decode (identity)", [
+        "The JSON Object already parsed from the wire is the domain value; no per-field transform.",
+        "Applies only where the spec names AnQst.Type.object as the field or root type."
+    ]);
+    return `${comment}
+function ${functionName}(value) {
+  return value;
+}`;
+}
+function emitCppDecoderSource(functionName = "decodeDynamicObjectFromJsonObject") {
+    const comment = (0, comments_1.emitStrategyComment)("AnQst.Type.object — C++ decode (QJsonObject → QVariantMap)", [
+        "Caller obtains QJsonObject from QJsonValue::toObject(); this helper maps to QVariantMap.",
+        "Thin QVariantMap-oriented helper; Qt headers required to compile."
+    ]);
+    return `${comment}
+inline QVariantMap ${functionName}(const QJsonObject& obj) {
+  return obj.toVariantMap();
+}`;
+}
+exports.decoder = {
+    descriptor: exports.descriptor,
+    emitTsDecoder: () => emitTsDecoderSource(),
+    emitCppDecoder: () => emitCppDecoderSource()
+};

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

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * AnQst base-type codec emitter: AnQst.Type.object (dynamic object).
+ *
+ * Wire: the value is a native JSON object with no transformation — pass-through for
+ * JSON.stringify / JSON.parse. This path applies only where the spec explicitly declares
+ * AnQst.Type.object (or AnQst.Type.json for the sibling codec); it is never a fallback for
+ * statically typed fields. Contents must be JSON-native (see Dynamic_object_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.object",
+    specPath: "RefinedSpecs/Codecs/Dynamic_object_Codec.md",
+    tsType: "object",
+    cppType: "QVariantMap",
+    wireCategory: "dynamic",
+    strategySummary: "Pass-through JSON Object on the wire for explicitly dynamic AnQst.Type.object only; no base93, no flattening."
+};
+function emitTsEncoderSource(functionName = "encodeDynamicObject") {
+    const comment = (0, comments_1.emitStrategyComment)("AnQst.Type.object — TypeScript encode (identity on wire payload)", [
+        "The domain object is emitted as-is; the surrounding codec / JSON.stringify supplies JSON Object syntax.",
+        "Reserved for spec-declared dynamic object fields or standalone dynamic payloads — not for static struct shapes.",
+        "Values must be JSON-serializable; non-JSON-native values fail at stringify time."
+    ]);
+    return `${comment}
+function ${functionName}(value) {
+  return value;
+}`;
+}
+function emitCppEncoderSource(functionName = "encodeDynamicObjectToJsonObject") {
+    const comment = (0, comments_1.emitStrategyComment)("AnQst.Type.object — C++ encode (QVariantMap → QJsonObject)", [
+        "Qt maps the domain QVariantMap to QJsonObject for JSON emission via QJsonObject::fromVariantMap.",
+        "Use only for explicit AnQst.Type.object; requires Qt JSON types in the translation unit."
+    ]);
+    return `${comment}
+inline QJsonObject ${functionName}(const QVariantMap& map) {
+  return QJsonObject::fromVariantMap(map);
+}`;
+}
+exports.encoder = {
+    descriptor: exports.descriptor,
+    emitTsEncoder: () => emitTsEncoderSource(),
+    emitCppEncoder: () => emitCppEncoderSource()
+};

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

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Base codec emitter: `AnQst.Type.int16` standalone decoder.
+ *
+ * Decoding mirrors `AnQst.Type.qint16`: base93 expands to 2 bytes, then
+ * `Int16Array` reconstructs the signed 16-bit two's complement value in native
+ * byte order. Descriptor identity remains separate so generated C++ binds to
+ * `int16_t`, not Qt's `qint16`.
+ */
+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 FIXED_WIDTH = encoder_1.descriptor.fixedWidth;
+const TS_FN = "decodeInt16Standalone";
+const CPP_FN = "decodeInt16Standalone";
+const STRATEGY_COMMENT = (0, comments_1.emitStrategyComment)("Base codec emitter (decode): AnQst.Type.int16 / int16_t", [
+    "Base93 decodes to exactly 2 bytes, then Int16Array reconstructs the signed 16-bit value in TypeScript.",
+    "The standalone wire remains the same 3-character payload used by qint16.",
+    "C++ decodes into int16_t with memcpy so the descriptor maps to the standard typedef, not qint16."
+]);
+exports.decoderEmitter = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${STRATEGY_COMMENT}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneDecoder)(TS_FN, FIXED_WIDTH)}`;
+    },
+    emitCppDecoder() {
+        return `${STRATEGY_COMMENT}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneDecoder)(CPP_FN, FIXED_WIDTH)}`;
+    }
+};

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

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Base codec emitter: `AnQst.Type.int16` standalone encoder.
+ *
+ * This codec is wire-identical to `AnQst.Type.qint16`: it writes the signed
+ * 16-bit two's complement value through `Int16Array`, then base93-encodes the
+ * resulting 2 native-order bytes as a 3-character standalone string. The
+ * descriptor stays distinct so generated C++ uses standard `int16_t`.
+ */
+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: "Int16Array",
+    cppType: "int16_t"
+};
+exports.descriptor = {
+    codecId: "integer-int16",
+    specPath: "RefinedSpecs/Codecs/Integer_int16_Codec.md",
+    tsType: "number",
+    cppType: "int16_t",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Wire-identical to qint16: serialize signed 16-bit two's complement via Int16Array / int16_t, then base93-encode the 2-byte standalone payload to 3 characters.",
+    fixedWidth: FIXED_WIDTH
+};
+const TS_FN = "encodeInt16Standalone";
+const CPP_FN = "encodeInt16Standalone";
+const STRATEGY_COMMENT = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.int16 / int16_t", [
+    "Wire-identical to qint16: TypeScript writes the signed 16-bit payload through Int16Array.",
+    "Standalone payload width is fixed at 2 bytes, which base93 encodes to exactly 3 characters.",
+    "C++ mirrors the same native-order bytes with memcpy into int16_t rather than Qt's qint16 typedef."
+]);
+exports.encoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${STRATEGY_COMMENT}\n\n${(0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)(TS_FN, FIXED_WIDTH)}`;
+    },
+    emitCppEncoder() {
+        return `${STRATEGY_COMMENT}\n\n${(0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)(CPP_FN, FIXED_WIDTH)}`;
+    }
+};

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

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Base codec emitter: `AnQst.Type.int32` standalone decoder.
+ *
+ * Decodes the same 5-character base93 wire used by `AnQst.Type.qint32`, then
+ * reconstructs the signed 32-bit two's complement value through `Int32Array`.
+ * Descriptor identity remains distinct so generated C++ uses `int32_t`, not
+ * Qt's `qint32`, even though the wire bytes are identical.
+ */
+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 = "decodeInt32Standalone";
+const CPP_FN = "decodeInt32Standalone";
+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-int32/encoder.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Base codec emitter: `AnQst.Type.int32` standalone encoder.
+ *
+ * Wire behavior is intentionally identical to `AnQst.Type.qint32`: serialize
+ * one signed 32-bit two's complement word via `Int32Array`, then base93-encode
+ * those 4 bytes into a 5-character standalone string. The distinction lives
+ * only in descriptor identity and C++ mapping: this codec targets `int32_t`.
+ */
+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: "int32_t"
+};
+exports.descriptor = {
+    codecId: "integer-int32",
+    specPath: "RefinedSpecs/Codecs/Integer_int32_Codec.md",
+    tsType: "number",
+    cppType: "int32_t",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Wire-identical to qint32: serialize int32_t 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 = "encodeInt32Standalone";
+const CPP_FN = "encodeInt32Standalone";
+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-int8/decoder.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Base codec emitter: `AnQst.Type.int8` standalone decoder.
+ *
+ * Decodes the same 2-character base93 wire used by `AnQst.Type.qint8`, then
+ * reconstructs the signed 8-bit two's complement value through `Int8Array`.
+ * Descriptor identity remains distinct so generated C++ uses `int8_t`, not Qt's
+ * `qint8`, even though the wire bytes are identical.
+ */
+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 fixedWidth = encoder_1.descriptor.fixedWidth;
+const TS_FN = "decodeInt8Standalone";
+const CPP_FN = "decodeInt8Standalone";
+exports.decoderEmitter = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return (0, fixedwidth_1.emitTsFixedWidthStandaloneDecoder)(TS_FN, fixedWidth);
+    },
+    emitCppDecoder() {
+        return (0, fixedwidth_1.emitCppFixedWidthStandaloneDecoder)(CPP_FN, fixedWidth);
+    }
+};

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

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Base codec emitter: `AnQst.Type.int8` standalone encoder.
+ *
+ * Wire behavior is intentionally identical to `AnQst.Type.qint8`: serialize one
+ * signed 8-bit two's complement byte via `Int8Array`, then base93-encode that
+ * single byte into a 2-character standalone string. The distinction lives only
+ * in descriptor identity and C++ mapping: this codec targets standard `int8_t`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoderEmitter = exports.descriptor = void 0;
+const fixedwidth_1 = require("../shared/fixedwidth");
+const fixedWidth = {
+    byteWidth: 1,
+    tsViewCtor: "Int8Array",
+    cppType: "int8_t"
+};
+exports.descriptor = {
+    codecId: "integer-int8",
+    specPath: "RefinedSpecs/Codecs/Integer_int8_Codec.md",
+    tsType: "number",
+    cppType: "int8_t",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Wire-identical to qint8: one signed two's complement byte via Int8Array / int8_t, base93-encoded as a 2-character standalone string.",
+    fixedWidth
+};
+const TS_FN = "encodeInt8Standalone";
+const CPP_FN = "encodeInt8Standalone";
+exports.encoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return (0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)(TS_FN, fixedWidth);
+    },
+    emitCppEncoder() {
+        return (0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)(CPP_FN, fixedWidth);
+    }
+};