@dusted/anqst 1.0.0 → 1.5.0

package/README.md

@@ -75,6 +75,8 @@ Settings file (`./AnQst/<WidgetName>.settings.json`) owns project-local AnQst co
   - If `QWidget` is enabled and `angular.json` exists:
     - runs production Angular build
     - embeds built web assets into generated Qt widget `webapp/`.
+  - Generated Qt integration CMake consumes the existing `./AnQst/generated` widget tree and fails fast if the required generated files are missing.
+  - Downstream CMake no longer invokes `npm`, `npx`, or `anqst`; run `anqst build` first, then build C++ against the generated tree.
   - If `--designerplugin` is enabled:
     - requires `ANQST_WEBBASE_DIR`
     - emits plugin sources in `./AnQst/generated/backend/cpp/qt/<WidgetName>_widget/designerPlugin`
@@ -140,3 +142,16 @@ code AnQst/BurgerConstructor.AnQst.d.ts
 npx @dusted/anqst test
 npx @dusted/anqst build
 ```
+
+## Two-stage workflow
+
+```bash
+# Stage 1: Node/Angular/generation environment
+npx @dusted/anqst build
+
+# Stage 2: pure Qt/CMake environment, consuming the generated tree
+cmake -S . -B build
+cmake --build build
+```
+
+Both stages must use the exact outputs from the same prior `anqst build` invocation.

package/dist/src/app.js

@@ -19,7 +19,7 @@ const project_1 = require("./project");
 const layout_1 = require("./layout");
 const parser_1 = require("./parser");
 const verify_1 = require("./verify");
-const build_stamp_1 = require("./build-stamp");
+const ANQSTGEN_ACTIVE_STAMP_FILE = ".anqstgen-version-active.json";
 function renderHelp() {
     const version = readActiveBuildStamp();
     return [
@@ -135,8 +135,27 @@ function runTest(cwd) {
         message: verification.message
     };
 }
+function resolveAnQstGenRoot() {
+    return node_path_1.default.resolve(__dirname, "..", "..");
+}
 function readActiveBuildStamp() {
-    return build_stamp_1.ANQST_BUILD_STAMP;
+    if (process.env.ANQST_BUILD_STAMP && process.env.ANQST_BUILD_STAMP.trim().length > 0) {
+        return process.env.ANQST_BUILD_STAMP.trim();
+    }
+    const activePath = node_path_1.default.join(resolveAnQstGenRoot(), ANQSTGEN_ACTIVE_STAMP_FILE);
+    if (!node_fs_1.default.existsSync(activePath)) {
+        return "unknown_build_0";
+    }
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(activePath, "utf8"));
+        if (typeof parsed.active === "string" && parsed.active.trim().length > 0) {
+            return parsed.active.trim();
+        }
+    }
+    catch {
+        // Fallback to deterministic unknown stamp.
+    }
+    return "unknown_build_0";
 }
 function runDesignerPluginBuild(cwd, widgetName) {
     const layout = (0, layout_1.resolveGeneratedLayoutPaths)(cwd, widgetName);
@@ -176,94 +195,101 @@ function runDesignerPluginBuild(cwd, widgetName) {
 }
 function runBuild(cwd, designerPlugin = false) {
     const buildVersion = readActiveBuildStamp();
-    const specPath = (0, project_1.resolveAnQstSpecPath)(cwd);
-    const configuredWidgetName = (0, project_1.resolveAnQstWidgetName)(cwd);
-    const generationTargets = resolveGenerationTargetsFromCwd(cwd, true);
-    const parsed = (0, parser_1.parseSpecFile)(specPath);
-    (0, verify_1.verifySpec)(parsed);
-    if (parsed.widgetName !== configuredWidgetName) {
-        throw new errors_1.VerifyError(`Settings widgetName '${configuredWidgetName}' does not match spec namespace '${parsed.widgetName}'.`);
-    }
-    resetGeneratedTargets(cwd, parsed.widgetName, generationTargets);
-    const outputs = (0, emit_1.generateOutputs)(parsed, generationTargets);
-    (0, emit_1.writeGeneratedOutputs)(cwd, outputs);
-    if (generationTargets.emitQWidget) {
-        (0, emit_1.installQtIntegrationCMake)(cwd, parsed.widgetName);
-    }
-    const hasAngularProject = generationTargets.emitQWidget && node_fs_1.default.existsSync(node_path_1.default.join(cwd, "angular.json"));
-    if (hasAngularProject) {
-        const angularBuild = (0, node_child_process_1.spawnSync)("npx", ["ng", "build", "--configuration", "production"], {
-            cwd,
-            stdio: "inherit",
-            shell: process.platform === "win32"
-        });
-        if (angularBuild.status !== 0) {
-            throw new errors_1.VerifyError("Angular build failed while preparing embedded widget assets.");
+    process.env.ANQST_BUILD_STAMP = buildVersion;
+    try {
+        const specPath = (0, project_1.resolveAnQstSpecPath)(cwd);
+        const configuredWidgetName = (0, project_1.resolveAnQstWidgetName)(cwd);
+        const generationTargets = resolveGenerationTargetsFromCwd(cwd, true);
+        const parsed = (0, parser_1.parseSpecFile)(specPath);
+        (0, verify_1.verifySpec)(parsed);
+        if (parsed.widgetName !== configuredWidgetName) {
+            throw new errors_1.VerifyError(`Settings widgetName '${configuredWidgetName}' does not match spec namespace '${parsed.widgetName}'.`);
         }
-    }
-    if (generationTargets.emitQWidget) {
-        const embedded = (0, emit_1.installEmbeddedWebBundle)(cwd, parsed.widgetName);
-        if (hasAngularProject && !embedded) {
-            throw new errors_1.VerifyError("Unable to embed Angular output. Ensure ng build produced a dist bundle with index.html.");
+        resetGeneratedTargets(cwd, parsed.widgetName, generationTargets);
+        const outputs = (0, emit_1.generateOutputs)(parsed, generationTargets);
+        (0, emit_1.writeGeneratedOutputs)(cwd, outputs);
+        if (generationTargets.emitQWidget) {
+            (0, emit_1.installQtIntegrationCMake)(cwd, parsed.widgetName);
         }
-    }
-    let designerPluginBuilt = false;
-    if (designerPlugin) {
-        if (!generationTargets.emitQWidget) {
-            console.warn("[AnQst] --designerplugin requested but QWidget target is not enabled. Skipping designer plugin build.");
+        const hasAngularProject = generationTargets.emitQWidget && node_fs_1.default.existsSync(node_path_1.default.join(cwd, "angular.json"));
+        if (hasAngularProject) {
+            const angularBuild = (0, node_child_process_1.spawnSync)("npx", ["ng", "build", "--configuration", "production"], {
+                cwd,
+                stdio: "inherit",
+                shell: process.platform === "win32"
+            });
+            if (angularBuild.status !== 0) {
+                throw new errors_1.VerifyError("Angular build failed while preparing embedded widget assets.");
+            }
         }
-        else {
-            const widgetCategory = (0, project_1.resolveAnQstWidgetCategory)(cwd);
-            (0, emit_1.installQtDesignerPluginCMake)(cwd, parsed.widgetName, { widgetCategory });
-            runDesignerPluginBuild(cwd, parsed.widgetName);
-            designerPluginBuilt = true;
+        if (generationTargets.emitQWidget) {
+            const embedded = (0, emit_1.installEmbeddedWebBundle)(cwd, parsed.widgetName);
+            if (hasAngularProject && !embedded) {
+                throw new errors_1.VerifyError("Unable to embed Angular output. Ensure ng build produced a dist bundle with index.html.");
+            }
+        }
+        let designerPluginBuilt = false;
+        if (designerPlugin) {
+            if (!generationTargets.emitQWidget) {
+                console.warn("[AnQst] --designerplugin requested but QWidget target is not enabled. Skipping designer plugin build.");
+            }
+            else {
+                const widgetCategory = (0, project_1.resolveAnQstWidgetCategory)(cwd);
+                (0, emit_1.installQtDesignerPluginCMake)(cwd, parsed.widgetName, { widgetCategory });
+                runDesignerPluginBuild(cwd, parsed.widgetName);
+                designerPluginBuilt = true;
+            }
+        }
+        if (!generationTargets.emitAngularService && !generationTargets.emitQWidget && !generationTargets.emitNodeExpressWs) {
+            return {
+                success: true,
+                message: [
+                    "Build completed.",
+                    `    anqst version ${buildVersion}`,
+                    "    No outputs selected by AnQst.generate."
+                ].join("\n")
+            };
+        }
+        const layout = (0, layout_1.resolveGeneratedLayoutPaths)(cwd, parsed.widgetName);
+        const detailLines = [];
+        if (generationTargets.emitAngularService) {
+            detailLines.push("    Target AngularService:");
+            detailLines.push(`      - Services output: ${(0, layout_1.toProjectRelative)(cwd, node_path_1.default.join(layout.frontendRoot, "services"))}`);
+            detailLines.push(`      - Types output: ${(0, layout_1.toProjectRelative)(cwd, node_path_1.default.join(layout.frontendRoot, "types"))}`);
+        }
+        if (generationTargets.emitQWidget) {
+            detailLines.push("    Target QWidget:");
+            detailLines.push(`      - Qt integration CMake: ${(0, layout_1.toProjectRelative)(cwd, node_path_1.default.join(layout.cppCmakeRoot, "CMakeLists.txt"))}`);
+            detailLines.push(`      - Widget output root: ${(0, layout_1.toProjectRelative)(cwd, layout.cppQtWidgetRoot)}`);
+            detailLines.push("      - C++ handoff: downstream CMake consumes this generated tree directly");
+            detailLines.push("      - Embedded web assets refreshed from Angular build");
+        }
+        if (generationTargets.emitNodeExpressWs) {
+            detailLines.push("    Target node_express_ws:");
+            detailLines.push(`      - Module output root: ${(0, layout_1.toProjectRelative)(cwd, layout.nodeExpressRoot)}`);
+        }
+        if (designerPluginBuilt) {
+            const pluginBinaryPath = (0, layout_1.normalizeSlashes)(node_path_1.default.join((0, layout_1.toProjectRelative)(cwd, layout.designerPluginBuildRoot), designerPluginBinaryName(parsed.widgetName)));
+            detailLines.push("    Target QtDesignerPlugin:");
+            detailLines.push(`      - Build output: ${(0, layout_1.toProjectRelative)(cwd, layout.designerPluginBuildRoot)}`);
+            detailLines.push(`      - Plugin binary: ${pluginBinaryPath}`);
+            detailLines.push("      - Install target dir: <QT_INSTALL_PLUGINS>/designer");
+            detailLines.push("      - Discover QT_INSTALL_PLUGINS: qmake -query QT_INSTALL_PLUGINS");
+            detailLines.push(`      - Example install: cp ${pluginBinaryPath} \"$(qmake -query QT_INSTALL_PLUGINS)/designer/\"`);
+            detailLines.push(`      - User-local install: mkdir -p \"$HOME/.local/lib/qt5/plugins/designer\" && cp ${pluginBinaryPath} \"$HOME/.local/lib/qt5/plugins/designer/\"`);
         }
-    }
-    if (!generationTargets.emitAngularService && !generationTargets.emitQWidget && !generationTargets.emitNodeExpressWs) {
         return {
             success: true,
             message: [
                 "Build completed.",
                 `    anqst version ${buildVersion}`,
-                "    No outputs selected by AnQst.generate."
+                ...detailLines
             ].join("\n")
         };
     }
-    const layout = (0, layout_1.resolveGeneratedLayoutPaths)(cwd, parsed.widgetName);
-    const detailLines = [];
-    if (generationTargets.emitAngularService) {
-        detailLines.push("    Target AngularService:");
-        detailLines.push(`      - Services output: ${(0, layout_1.toProjectRelative)(cwd, node_path_1.default.join(layout.frontendRoot, "services"))}`);
-        detailLines.push(`      - Types output: ${(0, layout_1.toProjectRelative)(cwd, node_path_1.default.join(layout.frontendRoot, "types"))}`);
-    }
-    if (generationTargets.emitQWidget) {
-        detailLines.push("    Target QWidget:");
-        detailLines.push(`      - Qt integration CMake: ${(0, layout_1.toProjectRelative)(cwd, node_path_1.default.join(layout.cppCmakeRoot, "CMakeLists.txt"))}`);
-        detailLines.push(`      - Widget output root: ${(0, layout_1.toProjectRelative)(cwd, layout.cppQtWidgetRoot)}`);
-        detailLines.push("      - Embedded web assets refreshed from Angular build");
-    }
-    if (generationTargets.emitNodeExpressWs) {
-        detailLines.push("    Target node_express_ws:");
-        detailLines.push(`      - Module output root: ${(0, layout_1.toProjectRelative)(cwd, layout.nodeExpressRoot)}`);
-    }
-    if (designerPluginBuilt) {
-        const pluginBinaryPath = (0, layout_1.normalizeSlashes)(node_path_1.default.join((0, layout_1.toProjectRelative)(cwd, layout.designerPluginBuildRoot), designerPluginBinaryName(parsed.widgetName)));
-        detailLines.push("    Target QtDesignerPlugin:");
-        detailLines.push(`      - Build output: ${(0, layout_1.toProjectRelative)(cwd, layout.designerPluginBuildRoot)}`);
-        detailLines.push(`      - Plugin binary: ${pluginBinaryPath}`);
-        detailLines.push("      - Install target dir: <QT_INSTALL_PLUGINS>/designer");
-        detailLines.push("      - Discover QT_INSTALL_PLUGINS: qmake -query QT_INSTALL_PLUGINS");
-        detailLines.push(`      - Example install: cp ${pluginBinaryPath} \"$(qmake -query QT_INSTALL_PLUGINS)/designer/\"`);
-        detailLines.push(`      - User-local install: mkdir -p \"$HOME/.local/lib/qt5/plugins/designer\" && cp ${pluginBinaryPath} \"$HOME/.local/lib/qt5/plugins/designer/\"`);
+    finally {
+        delete process.env.ANQST_BUILD_STAMP;
     }
-    return {
-        success: true,
-        message: [
-            "Build completed.",
-            `    anqst version ${buildVersion}`,
-            ...detailLines
-        ].join("\n")
-    };
 }
 function parseSpecCommandArg(commandName, specArg, extraArgs) {
     const allArgs = [specArg, ...extraArgs].filter((arg) => typeof arg === "string" && arg.length > 0);

package/dist/src/base93.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE93_ALPHABET = void 0;
+exports.emitBase93Encoder = emitBase93Encoder;
+exports.emitBase93Decoder = emitBase93Decoder;
+exports.emitBase93CppFunctions = emitBase93CppFunctions;
+exports.BASE93_ALPHABET = Array.from({ length: 95 }, (_, i) => String.fromCharCode(0x20 + i))
+    .filter(c => c !== '"' && c !== '\\')
+    .join('');
+function emitBase93Encoder() {
+    return `function(d) {
+var A = "${exports.BASE93_ALPHABET}", n = d.length, f = n >>> 2, r = n & 3,
+o = new Array(f * 5 + (r ? r + 1 : 0)), p = 0, i, v, b, j;
+for (i = 0; i < f; i++) {
+b = i << 2;
+v = ((d[b] << 24) | (d[b+1] << 16) | (d[b+2] << 8) | d[b+3]) >>> 0;
+o[p+4] = A[v % 93]; v = (v / 93) | 0;
+o[p+3] = A[v % 93]; v = (v / 93) | 0;
+o[p+2] = A[v % 93]; v = (v / 93) | 0;
+o[p+1] = A[v % 93];
+o[p] = A[(v / 93) | 0];
+p += 5;
+}
+if (r) {
+b = f << 2; v = 0;
+for (j = 0; j < r; j++) v = (v << 8) | d[b + j];
+for (j = r; j >= 0; j--) { o[p + j] = A[v % 93]; v = (v / 93) | 0; }
+}
+return o.join("");
+}`;
+}
+function emitBase93Decoder() {
+    return `function(s) {
+var n = s.length, f = (n / 5) | 0, r = n - f * 5,
+o = new Uint8Array(f * 4 + (r ? r - 1 : 0)), p = 0, i, v, c, b;
+for (i = 0; i < f; i++) {
+b = i * 5;
+c = s.charCodeAt(b); v = c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0);
+c = s.charCodeAt(b + 1); v = v * 93 + c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0);
+c = s.charCodeAt(b + 2); v = v * 93 + c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0);
+c = s.charCodeAt(b + 3); v = v * 93 + c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0);
+c = s.charCodeAt(b + 4); v = v * 93 + c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0);
+o[p] = v >>> 24; o[p+1] = (v >>> 16) & 255; o[p+2] = (v >>> 8) & 255; o[p+3] = v & 255;
+p += 4;
+}
+if (r) {
+v = 0;
+for (i = 0; i < r; i++) { c = s.charCodeAt(f * 5 + i); v = v * 93 + c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0); }
+for (i = r - 2; i >= 0; i--) { o[p + i] = v & 255; v = (v / 256) | 0; }
+}
+return o;
+}`;
+}
+function emitBase93CppFunctions() {
+    return `inline int base93AlphabetIndex(char c) {
+  const unsigned char uc = static_cast<unsigned char>(c);
+  return static_cast<int>(uc) - 32 - (uc > 34) - (uc > 92);
+}
+
+inline std::string base93Encode(const std::vector<std::uint8_t>& d) {
+  static constexpr char A[] = "${exports.BASE93_ALPHABET}";
+  const std::size_t n = d.size();
+  const std::size_t f = n >> 2;
+  const std::size_t r = n & 3;
+  std::string o(f * 5 + (r ? r + 1 : 0), '\\0');
+  std::size_t p = 0;
+  for (std::size_t i = 0; i < f; ++i) {
+    const std::size_t b = i << 2;
+    std::uint32_t v =
+      (static_cast<std::uint32_t>(d[b]) << 24) |
+      (static_cast<std::uint32_t>(d[b + 1]) << 16) |
+      (static_cast<std::uint32_t>(d[b + 2]) << 8) |
+      static_cast<std::uint32_t>(d[b + 3]);
+    o[p + 4] = A[v % 93u]; v /= 93u;
+    o[p + 3] = A[v % 93u]; v /= 93u;
+    o[p + 2] = A[v % 93u]; v /= 93u;
+    o[p + 1] = A[v % 93u];
+    o[p] = A[v / 93u];
+    p += 5;
+  }
+  if (r) {
+    const std::size_t b = f << 2;
+    std::uint32_t v = 0;
+    for (std::size_t j = 0; j < r; ++j) v = (v << 8) | d[b + j];
+    for (std::size_t j = r + 1; j-- > 0;) {
+      o[p + j] = A[v % 93u];
+      v /= 93u;
+    }
+  }
+  return o;
+}
+
+inline std::vector<std::uint8_t> base93Decode(const std::string& s) {
+  const std::size_t n = s.size();
+  const std::size_t f = n / 5;
+  const std::size_t r = n - f * 5;
+  std::vector<std::uint8_t> o(f * 4 + (r ? r - 1 : 0));
+  std::size_t p = 0;
+  for (std::size_t i = 0; i < f; ++i) {
+    const std::size_t b = i * 5;
+    std::uint32_t v = static_cast<std::uint32_t>(base93AlphabetIndex(s[b]));
+    v = v * 93u + static_cast<std::uint32_t>(base93AlphabetIndex(s[b + 1]));
+    v = v * 93u + static_cast<std::uint32_t>(base93AlphabetIndex(s[b + 2]));
+    v = v * 93u + static_cast<std::uint32_t>(base93AlphabetIndex(s[b + 3]));
+    v = v * 93u + static_cast<std::uint32_t>(base93AlphabetIndex(s[b + 4]));
+    o[p] = static_cast<std::uint8_t>(v >> 24);
+    o[p + 1] = static_cast<std::uint8_t>((v >> 16) & 255u);
+    o[p + 2] = static_cast<std::uint8_t>((v >> 8) & 255u);
+    o[p + 3] = static_cast<std::uint8_t>(v & 255u);
+    p += 4;
+  }
+  if (r) {
+    std::uint32_t v = 0;
+    for (std::size_t i = 0; i < r; ++i) {
+      v = v * 93u + static_cast<std::uint32_t>(base93AlphabetIndex(s[f * 5 + i]));
+    }
+    for (std::size_t i = r - 1; i-- > 0;) {
+      o[p + i] = static_cast<std::uint8_t>(v & 255u);
+      v /= 256u;
+    }
+  }
+  return o;
+}`;
+}

package/dist/src/build-stamp.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ANQST_BUILD_STAMP = void 0;
 // Generated by scripts/build-with-stamp.js. Do not edit by hand.
-exports.ANQST_BUILD_STAMP = "1.0.0/7bd720a_dirty_build_1/2026-03-29";
+exports.ANQST_BUILD_STAMP = "unknown/unknown_build_0/1970-01-01";

package/dist/src/codecgenerators/basecodecemitters/bigint-qint64/decoder.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Base codec emitter: AnQst.Type.qint64 — TypeScript decoder (standalone base93 string → bigint).
+ *
+ * - Decodes base93 to 8 bytes, then reads signed 64-bit two's complement via BigInt64Array.
+ * - C++ decoder uses memcpy from decoded bytes into qint64 (see emitCppDecoder).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoderEmitter = exports.descriptor = void 0;
+const fixedwidth_1 = require("../shared/fixedwidth");
+const FIXED_WIDTH = {
+    byteWidth: 8,
+    tsViewCtor: "BigInt64Array",
+    cppType: "qint64"
+};
+exports.descriptor = {
+    codecId: "bigint-qint64",
+    specPath: "RefinedSpecs/Codecs/BigInt_qint64_Codec.md",
+    tsType: "bigint",
+    cppType: "qint64",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "Decode standalone base93 to 8 bytes, reinterpret as qint64 / BigInt64Array[0] as bigint.",
+    fixedWidth: FIXED_WIDTH
+};
+const TS_FN = "decodeQint64Standalone";
+const CPP_FN = "decodeQint64Standalone";
+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/bigint-qint64/encoder.js

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

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Decoder emitter for the AnQst base-type codec `AnQst.Type.quint64`.
+ *
+ * Reverses the standalone encoder: base93 string → 8 bytes → `BigUint64Array` → bigint (≥ 0n).
+ * C++ decodes to `quint64` via `std::memcpy` from decoded bytes.
+ *
+ * Spec: RefinedSpecs/Codecs/BigInt_quint64_Codec.md
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoder = 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 = "decodeQuint64Standalone";
+const CPP_FN = "decodeQuint64Standalone";
+exports.decoder = {
+    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/bigint-quint64/encoder.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Emitter for the AnQst base-type codec `AnQst.Type.quint64`.
+ *
+ * Maps TypeScript `bigint` to an 8-byte unsigned little-endian representation via
+ * `BigUint64Array`, then to a standalone base93 string (10 characters). C++ uses
+ * `quint64` with `std::memcpy` for the same 8-byte layout on the host platform.
+ *
+ * Spec: RefinedSpecs/Codecs/BigInt_quint64_Codec.md
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoder = exports.descriptor = void 0;
+const fixedwidth_1 = require("../shared/fixedwidth");
+const fixedWidth = {
+    byteWidth: 8,
+    tsViewCtor: "BigUint64Array",
+    cppType: "quint64"
+};
+exports.descriptor = {
+    codecId: "bigint-quint64",
+    specPath: "RefinedSpecs/Codecs/BigInt_quint64_Codec.md",
+    tsType: "bigint",
+    cppType: "quint64",
+    wireCategory: "fixed-width-scalar",
+    strategySummary: "8-byte unsigned host-endian representation (BigUint64Array / memcpy into quint64), base93 standalone string (10 chars).",
+    fixedWidth
+};
+const TS_FN = "encodeQuint64Standalone";
+const CPP_FN = "encodeQuint64Standalone";
+exports.encoder = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return (0, fixedwidth_1.emitTsFixedWidthStandaloneEncoder)(TS_FN, fixedWidth);
+    },
+    emitCppEncoder() {
+        return (0, fixedwidth_1.emitCppFixedWidthStandaloneEncoder)(CPP_FN, fixedWidth);
+    }
+};

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

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Base codec emitter (decode): `AnQst.Type.blob`.
+ * Decoding mirrors `AnQst.Type.buffer`: base93 text reconstructs the original raw bytes as ArrayBuffer/QByteArray.
+ * This file preserves blob-specific descriptor identity while reusing the shared raw-byte scaffold.
+ */
+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 = "decodeBinaryBlobStandalone";
+const CPP_FN = "decodeBinaryBlobStandalone";
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (decode): AnQst.Type.blob / QByteArray", [
+    "Base93-decodes the standalone wire string back into the original opaque byte sequence.",
+    "Wire layout is intentionally identical to AnQst.Type.buffer; the distinction is semantic descriptor metadata.",
+    "Expects base93Decode in scope; C++ reconstructs QByteArray directly from decoded bytes."
+]);
+exports.decoderEmitter = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${strategyComment}\n\n${(0, rawbytes_1.emitTsRawByteStandaloneDecoder)(TS_FN, "bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)")}`;
+    },
+    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-blob/encoder.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Base codec emitter (encode): `AnQst.Type.blob`.
+ * Wire shape is identical to `AnQst.Type.buffer`: raw ArrayBuffer bytes become one base93 string.
+ * This emitter keeps distinct blob descriptor metadata while reusing the shared raw-byte scaffold.
+ */
+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-blob",
+    specPath: "RefinedSpecs/Codecs/Binary_blob_Codec.md",
+    tsType: "ArrayBuffer",
+    cppType: "QByteArray",
+    wireCategory: "binary",
+    strategySummary: "Serialize ArrayBuffer / QByteArray raw bytes as one base93 string; wire-identical to buffer, but with blob-specific descriptor metadata."
+};
+const TS_FN = "encodeBinaryBlobStandalone";
+const CPP_FN = "encodeBinaryBlobStandalone";
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.blob / QByteArray", [
+    "Treats the payload as opaque bytes and base93-encodes them into one standalone JSON string.",
+    "Wire layout is intentionally identical to AnQst.Type.buffer; only descriptor identity differs.",
+    "Expects base93Encode in scope; C++ path reads QByteArray bytes without adding length/type metadata."
+]);
+exports.encoderEmitter = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${strategyComment}\n\n${(0, rawbytes_1.emitTsRawByteStandaloneEncoder)(TS_FN, "new Uint8Array(value)")}`;
+    },
+    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()) + value.size())")}`;
+    }
+};

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

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Base codec emitter (decode): standalone base93 string → `ArrayBuffer` / `QByteArray`.
+ * The decoder reconstructs the exact raw byte sequence and returns the decoded backing buffer in TS.
+ * Composite codecs must decide where buffer-length metadata lives when a variable-length buffer shares a
+ * payload with sibling fields; this file only emits the standalone leaf helper and documents that strategy.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoder = 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 = "decodeAnqstBase_buffer";
+const CPP_FN = "decodeAnqstBase_buffer";
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (decode): AnQst.Type.buffer / ArrayBuffer", [
+    "Base93-decodes the standalone wire string to raw bytes and returns the resulting opaque byte sequence.",
+    "TypeScript returns the ArrayBuffer backing the decoded Uint8Array without an extra copy; C++ rebuilds QByteArray from decoded bytes.",
+    "Composite codecs should read byte-length metadata from their planned numeric blob or trailing-position convention before consuming a buffer payload; that structured orchestration is intentionally not wired here."
+]);
+exports.decoder = {
+    descriptor: encoder_1.descriptor,
+    emitTsDecoder() {
+        return `${strategyComment}\n\n${(0, rawbytes_1.emitTsRawByteStandaloneDecoder)(TS_FN, "bytes.buffer")}`;
+    },
+    emitCppDecoder() {
+        return `${strategyComment}\n\n${(0, rawbytes_1.emitCppRawByteStandaloneDecoder)(CPP_FN, "QByteArray(bytes.begin(), bytes.end())")}`;
+    }
+};

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

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Base codec emitter (encode): `AnQst.Type.buffer` / `ArrayBuffer` ↔ `QByteArray`.
+ * Standalone wire shape is one base93 string over the raw bytes, including `""` for an empty buffer.
+ * Composite codecs should keep the variable-length buffer payload in its own string slot and pair it with
+ * byte-length metadata when sibling fields make boundaries ambiguous; that structured integration is
+ * documented here but intentionally not emitted by this leaf helper.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encoder = exports.descriptor = void 0;
+const comments_1 = require("../shared/comments");
+const rawbytes_1 = require("../shared/rawbytes");
+exports.descriptor = {
+    codecId: "AnQst.Type.buffer",
+    specPath: "RefinedSpecs/Codecs/Binary_buffer_Codec.md",
+    tsType: "ArrayBuffer",
+    cppType: "QByteArray",
+    wireCategory: "binary",
+    strategySummary: "ArrayBuffer/QByteArray raw bytes encoded as one standalone base93 string; composite codecs keep the payload in its own string slot and carry byte length separately when needed."
+};
+const TS_FN = "encodeAnqstBase_buffer";
+const CPP_FN = "encodeAnqstBase_buffer";
+const strategyComment = (0, comments_1.emitStrategyComment)("Base codec emitter (encode): AnQst.Type.buffer / ArrayBuffer", [
+    "Treats the domain value as an opaque byte sequence and base93-encodes it as one standalone string.",
+    "TypeScript reads bytes through Uint8Array(value); C++ reads QByteArray through begin()/end() into std::vector<std::uint8_t>.",
+    "Composite codecs should keep this variable-length payload in its own wire string position and carry byte-length metadata separately when boundary disambiguation is required; that orchestration is not emitted here."
+]);
+exports.encoder = {
+    descriptor: exports.descriptor,
+    emitTsEncoder() {
+        return `${strategyComment}\n\n${(0, rawbytes_1.emitTsRawByteStandaloneEncoder)(TS_FN, "new Uint8Array(value)")}`;
+    },
+    emitCppEncoder() {
+        return `${strategyComment}\n\n${(0, rawbytes_1.emitCppRawByteStandaloneEncoder)(CPP_FN, "std::vector<std::uint8_t>(value.begin(), value.end())")}`;
+    }
+};