@dusted/anqst 1.0.1 → 1.5.1

package/dist/src/emit.js

@@ -13,6 +13,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const typescript_1 = __importDefault(require("typescript"));
 const pngjs_1 = require("pngjs");
 const layout_1 = require("./layout");
+const boundary_codecs_1 = require("./boundary-codecs");
 function stripAnQstType(typeText) {
     return typeText
         .replace(/\bAnQst\.Type\.stringArray\b/g, "string[]")
@@ -22,6 +23,27 @@ function stripAnQstType(typeText) {
         .replace(/\bAnQst\.Type\.quint64\b/g, "bigint")
         .replace(/\bAnQst\.Type\.qint32\b/g, "number")
         .replace(/\bAnQst\.Type\.quint32\b/g, "number")
+        .replace(/\bAnQst\.Type\.qint16\b/g, "number")
+        .replace(/\bAnQst\.Type\.quint16\b/g, "number")
+        .replace(/\bAnQst\.Type\.qint8\b/g, "number")
+        .replace(/\bAnQst\.Type\.quint8\b/g, "number")
+        .replace(/\bAnQst\.Type\.int32\b/g, "number")
+        .replace(/\bAnQst\.Type\.uint32\b/g, "number")
+        .replace(/\bAnQst\.Type\.int16\b/g, "number")
+        .replace(/\bAnQst\.Type\.uint16\b/g, "number")
+        .replace(/\bAnQst\.Type\.int8\b/g, "number")
+        .replace(/\bAnQst\.Type\.uint8\b/g, "number")
+        .replace(/\bAnQst\.Type\.buffer\b/g, "ArrayBuffer")
+        .replace(/\bAnQst\.Type\.blob\b/g, "ArrayBuffer")
+        .replace(/\bAnQst\.Type\.typedArray\b/g, "Uint8Array")
+        .replace(/\bAnQst\.Type\.uint8Array\b/g, "Uint8Array")
+        .replace(/\bAnQst\.Type\.int8Array\b/g, "Int8Array")
+        .replace(/\bAnQst\.Type\.uint16Array\b/g, "Uint16Array")
+        .replace(/\bAnQst\.Type\.int16Array\b/g, "Int16Array")
+        .replace(/\bAnQst\.Type\.uint32Array\b/g, "Uint32Array")
+        .replace(/\bAnQst\.Type\.int32Array\b/g, "Int32Array")
+        .replace(/\bAnQst\.Type\.float32Array\b/g, "Float32Array")
+        .replace(/\bAnQst\.Type\.float64Array\b/g, "Float64Array")
         .replace(/\bAnQst\.Type\.object\b/g, "object")
         .replace(/\bAnQst\.Type\.json\b/g, "object");
 }
@@ -31,6 +53,129 @@ function splitGeneric(typeText) {
         return null;
     return { name: m[1], arg: m[2].trim() };
 }
+function filterNullishUnionTypeNodes(types) {
+    return types.filter((part) => part.kind !== typescript_1.default.SyntaxKind.NullKeyword && part.kind !== typescript_1.default.SyntaxKind.UndefinedKeyword);
+}
+function isStringLikeUnionTypeNode(node) {
+    return node.types.every((part) => {
+        if (typescript_1.default.isLiteralTypeNode(part) && typescript_1.default.isStringLiteral(part.literal))
+            return true;
+        if (part.kind === typescript_1.default.SyntaxKind.StringKeyword)
+            return true;
+        return false;
+    });
+}
+function isBooleanLikeUnionTypeNode(node) {
+    return node.types.every((part) => {
+        if (typescript_1.default.isLiteralTypeNode(part) && (part.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword || part.literal.kind === typescript_1.default.SyntaxKind.FalseKeyword))
+            return true;
+        if (part.kind === typescript_1.default.SyntaxKind.BooleanKeyword)
+            return true;
+        return false;
+    });
+}
+function isNumberLikeUnionTypeNode(node) {
+    return node.types.every((part) => {
+        if (typescript_1.default.isLiteralTypeNode(part) && typescript_1.default.isNumericLiteral(part.literal))
+            return true;
+        if (part.kind === typescript_1.default.SyntaxKind.NumberKeyword || part.kind === typescript_1.default.SyntaxKind.BigIntKeyword)
+            return true;
+        return false;
+    });
+}
+function collectFiniteStringLiteralsTypeNode(node) {
+    const values = [];
+    for (const part of node.types) {
+        if (!typescript_1.default.isLiteralTypeNode(part) || !typescript_1.default.isStringLiteral(part.literal))
+            return null;
+        values.push(part.literal.text);
+    }
+    return values;
+}
+function collectFiniteBooleanLiteralsTypeNode(node) {
+    const values = [];
+    for (const part of node.types) {
+        if (!typescript_1.default.isLiteralTypeNode(part))
+            return null;
+        if (part.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword) {
+            values.push(true);
+            continue;
+        }
+        if (part.literal.kind === typescript_1.default.SyntaxKind.FalseKeyword) {
+            values.push(false);
+            continue;
+        }
+        return null;
+    }
+    return values;
+}
+function collectFiniteNumberLiteralsTypeNode(node) {
+    const values = [];
+    for (const part of node.types) {
+        if (!typescript_1.default.isLiteralTypeNode(part) || !typescript_1.default.isNumericLiteral(part.literal))
+            return null;
+        values.push(Number(part.literal.text));
+    }
+    return values;
+}
+function finiteDomainSymbolForCpp(value) {
+    if (typeof value === "boolean")
+        return value ? "True" : "False";
+    if (typeof value === "number") {
+        const text = Number.isInteger(value) ? `${value}` : `${value}`.replace(/\./g, "_");
+        return sanitizeIdentifier(`Value_${text.replace(/-/g, "neg_")}`);
+    }
+    const direct = sanitizeIdentifier(value.trim());
+    return direct.length > 0 ? direct : "Value";
+}
+function buildCppFiniteDomain(primitive, values) {
+    const seen = new Set();
+    const variants = [];
+    for (const value of values) {
+        const key = `${typeof value}:${String(value)}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        variants.push({
+            code: variants.length,
+            symbolicName: finiteDomainSymbolForCpp(value),
+            value
+        });
+    }
+    return { primitive, variants };
+}
+function collectFiniteDomainFromTypeNode(typeNode) {
+    if (typescript_1.default.isParenthesizedTypeNode(typeNode)) {
+        return collectFiniteDomainFromTypeNode(typeNode.type);
+    }
+    if (typescript_1.default.isLiteralTypeNode(typeNode)) {
+        if (typescript_1.default.isStringLiteral(typeNode.literal)) {
+            return buildCppFiniteDomain("string", [typeNode.literal.text]);
+        }
+        if (typescript_1.default.isNumericLiteral(typeNode.literal)) {
+            return buildCppFiniteDomain("number", [Number(typeNode.literal.text)]);
+        }
+        if (typeNode.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword || typeNode.literal.kind === typescript_1.default.SyntaxKind.FalseKeyword) {
+            return buildCppFiniteDomain("boolean", [typeNode.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword]);
+        }
+        return null;
+    }
+    if (!typescript_1.default.isUnionTypeNode(typeNode))
+        return null;
+    const filtered = filterNullishUnionTypeNodes(typeNode.types);
+    if (filtered.length !== typeNode.types.length)
+        return null;
+    const finiteStrings = collectFiniteStringLiteralsTypeNode(typeNode);
+    if (finiteStrings)
+        return buildCppFiniteDomain("string", finiteStrings);
+    const finiteBooleans = collectFiniteBooleanLiteralsTypeNode(typeNode);
+    if (finiteBooleans)
+        return buildCppFiniteDomain("boolean", finiteBooleans);
+    const finiteNumbers = collectFiniteNumberLiteralsTypeNode(typeNode);
+    if (finiteNumbers)
+        return buildCppFiniteDomain("number", finiteNumbers);
+    return null;
+}
 function mapTsTypeToCpp(typeText) {
     const raw = typeText.trim();
     if (/\bAnQst\.Type\.qint64\b/.test(raw))
@@ -55,6 +200,9 @@ function mapTsTypeToCpp(typeText) {
         return "QString";
     if (/\bAnQst\.Type\.json\b/.test(raw) || /\bAnQst\.Type\.object\b/.test(raw))
         return "QVariantMap";
+    if (/\bAnQst\.Type\.(?:buffer|blob|typedArray|uint8Array|int8Array|uint16Array|int16Array|uint32Array|int32Array|float32Array|float64Array)\b/.test(raw)) {
+        return "QByteArray";
+    }
     if (/\bAnQst\.Type\.(u?int(8|16|32))\b/.test(raw)) {
         const narrowed = raw.match(/\bAnQst\.Type\.(u?int(?:8|16|32))\b/)?.[1];
         if (narrowed === "int8")
@@ -83,6 +231,20 @@ function mapTsTypeToCpp(typeText) {
         return "void";
     if (t === "object")
         return "QVariantMap";
+    if (t === "ArrayBuffer")
+        return "QByteArray";
+    if ([
+        "Uint8Array",
+        "Int8Array",
+        "Uint16Array",
+        "Int16Array",
+        "Uint32Array",
+        "Int32Array",
+        "Float32Array",
+        "Float64Array"
+    ].includes(t)) {
+        return "QByteArray";
+    }
     if (t.endsWith("[]")) {
         return `QList<${mapTsTypeToCpp(t.slice(0, -2))}>`;
     }
@@ -110,6 +272,11 @@ function callbackName(memberName) {
 function pascalCase(value) {
     return value.length === 0 ? value : `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
 }
+function sanitizeIdentifier(value) {
+    const trimmed = value.replace(/[^A-Za-z0-9_]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+    const withFallback = trimmed.length > 0 ? trimmed : "Codec";
+    return /^[0-9]/.test(withFallback) ? `T_${withFallback}` : withFallback;
+}
 function variantToCppExpression(cppType, expr) {
     if (cppType === "QString")
         return `${expr}.toString()`;
@@ -117,6 +284,8 @@ function variantToCppExpression(cppType, expr) {
         return `${expr}.toStringList()`;
     if (cppType === "QVariantMap")
         return `${expr}.toMap()`;
+    if (cppType === "QByteArray")
+        return `${expr}.toByteArray()`;
     if (cppType === "double")
         return `${expr}.toDouble()`;
     if (cppType === "bool")
@@ -140,6 +309,7 @@ function cppToVariantExpression(cppType, expr) {
     if (cppType === "QString" ||
         cppType === "QStringList" ||
         cppType === "QVariantMap" ||
+        cppType === "QByteArray" ||
         cppType === "double" ||
         cppType === "bool" ||
         cppType === "qint64" ||
@@ -398,6 +568,8 @@ class CppTypeNormalizer {
         this.seedOrder = [];
         this.allKnownNames = new Set();
         this.usedNames = new Set();
+        this.syntheticNameByKey = new Map();
+        this.finiteDomainNameByKey = new Map();
         for (const decl of collectStructDecls(spec)) {
             this.allKnownNames.add(decl.name);
             this.usedNames.add(decl.name);
@@ -421,9 +593,11 @@ class CppTypeNormalizer {
         const order = this.topologicalOrder();
         const orderedDecls = order.map((name) => this.declMap.get(name)).filter((x) => !!x);
         const structNames = orderedDecls.filter((d) => d.kind === "struct").map((d) => d.name);
+        const metatypeNames = orderedDecls.filter((d) => d.kind === "struct" || d.kind === "enum").map((d) => d.name);
         return {
             orderedDecls,
             structNames,
+            metatypeNames,
             mapTypeText: (typeText, nameHintParts) => this.mapTypeText(typeText, nameHintParts)
         };
     }
@@ -441,7 +615,19 @@ class CppTypeNormalizer {
                     optional: !!member.questionToken
                 });
             }
-            return { name, kind: "struct", fields, aliasType: null, deps, isUnionAlias: false };
+            return { name, kind: "struct", fields, aliasType: null, deps, isUnionAlias: false, finiteDomain: null };
+        }
+        const finiteDomain = collectFiniteDomainFromTypeNode(node.type);
+        if (finiteDomain) {
+            return {
+                name,
+                kind: "enum",
+                fields: [],
+                aliasType: null,
+                deps: new Set(),
+                isUnionAlias: false,
+                finiteDomain
+            };
         }
         const deps = new Set();
         const aliasType = this.mapTypeNode(node.type, [name], deps);
@@ -451,14 +637,29 @@ class CppTypeNormalizer {
             fields: [],
             aliasType,
             deps,
-            isUnionAlias: node.type.getText().includes("|")
+            isUnionAlias: node.type.getText().includes("|"),
+            finiteDomain: null
         };
     }
     mapTypeNode(typeNode, nameHintParts, deps) {
         if (typescript_1.default.isParenthesizedTypeNode(typeNode)) {
             return this.mapTypeNode(typeNode.type, nameHintParts, deps);
         }
+        const finiteDomain = collectFiniteDomainFromTypeNode(typeNode);
+        if (finiteDomain) {
+            return this.ensureFiniteDomainType(finiteDomain, nameHintParts, deps);
+        }
         if (typescript_1.default.isUnionTypeNode(typeNode)) {
+            const filtered = filterNullishUnionTypeNodes(typeNode.types);
+            if (filtered.length === 1) {
+                return this.mapTypeNode(filtered[0], nameHintParts, deps);
+            }
+            if (isStringLikeUnionTypeNode(typeNode))
+                return "QString";
+            if (isBooleanLikeUnionTypeNode(typeNode))
+                return "bool";
+            if (isNumberLikeUnionTypeNode(typeNode))
+                return "double";
             return "QString";
         }
         if (typescript_1.default.isTypeLiteralNode(typeNode)) {
@@ -504,9 +705,44 @@ class CppTypeNormalizer {
         this.collectKnownTypeDeps(mapped, deps);
         return mapped;
     }
+    ensureFiniteDomainType(domain, nameHintParts, deps) {
+        const baseName = this.makeSyntheticBaseName(nameHintParts);
+        const domainKey = `${baseName}::finite::${domain.primitive}::${domain.variants.map((variant) => `${variant.symbolicName}=${String(variant.value)}`).join("|")}`;
+        const existingName = this.finiteDomainNameByKey.get(domainKey);
+        if (existingName) {
+            deps.add(existingName);
+            return existingName;
+        }
+        const synthesizedName = this.allocateUniqueName(baseName);
+        this.finiteDomainNameByKey.set(domainKey, synthesizedName);
+        if (this.declMap.has(synthesizedName)) {
+            deps.add(synthesizedName);
+            return synthesizedName;
+        }
+        this.allKnownNames.add(synthesizedName);
+        this.declMap.set(synthesizedName, {
+            name: synthesizedName,
+            kind: "enum",
+            fields: [],
+            aliasType: null,
+            deps: new Set(),
+            isUnionAlias: false,
+            finiteDomain: domain
+        });
+        this.seedOrder.push(synthesizedName);
+        deps.add(synthesizedName);
+        return synthesizedName;
+    }
     ensureSyntheticStruct(typeNode, nameHintParts, deps) {
         const baseName = this.makeSyntheticBaseName(nameHintParts);
+        const syntheticKey = `${baseName}::${typeNode.getText()}`;
+        const existingName = this.syntheticNameByKey.get(syntheticKey);
+        if (existingName) {
+            deps.add(existingName);
+            return existingName;
+        }
         const synthesizedName = this.allocateUniqueName(baseName);
+        this.syntheticNameByKey.set(syntheticKey, synthesizedName);
         if (this.declMap.has(synthesizedName)) {
             deps.add(synthesizedName);
             return synthesizedName;
@@ -530,7 +766,8 @@ class CppTypeNormalizer {
             fields,
             aliasType: null,
             deps: localDeps,
-            isUnionAlias: false
+            isUnionAlias: false,
+            finiteDomain: null
         });
         this.seedOrder.push(synthesizedName);
         deps.add(synthesizedName);
@@ -592,6 +829,17 @@ class CppTypeNormalizer {
     }
 }
 function renderCppDecl(decl) {
+    if (decl.kind === "enum") {
+        const variants = decl.finiteDomain?.variants ?? [];
+        const underlyingType = variants.length <= 0xff ? "std::uint8_t" : variants.length <= 0xffff ? "std::uint16_t" : "std::uint32_t";
+        const lines = [];
+        lines.push(`enum class ${decl.name} : ${underlyingType} {`);
+        for (const variant of variants) {
+            lines.push(`    ${variant.symbolicName} = ${variant.code},`);
+        }
+        lines.push("};");
+        return lines.join("\n");
+    }
     if (decl.kind === "alias") {
         if (decl.isUnionAlias && decl.aliasType === "QString") {
             return `using ${decl.name} = QString; // union mapped conservatively`;
@@ -647,9 +895,247 @@ function collectDragDropMimeConstants(spec) {
     }
     return constants;
 }
+function createCarrierSummary(counts, singleKinds = [], mayBlob = false, mustBlob = false) {
+    return {
+        counts: new Set(counts),
+        singleKinds: new Set(singleKinds),
+        mayBlob,
+        mustBlob
+    };
+}
+function addOptionalAbsence(summary) {
+    const counts = new Set(summary.counts);
+    counts.add(0);
+    return {
+        counts,
+        singleKinds: new Set(summary.singleKinds),
+        mayBlob: summary.mayBlob,
+        mustBlob: summary.mustBlob
+    };
+}
+function saturatingItemCountAdd(left, right) {
+    if (left === 2 || right === 2)
+        return 2;
+    const total = left + right;
+    return total >= 2 ? 2 : total;
+}
+function mergeCarrierSummaries(left, right) {
+    const counts = new Set();
+    const singleKinds = new Set();
+    for (const leftCount of left.counts) {
+        for (const rightCount of right.counts) {
+            const total = saturatingItemCountAdd(leftCount, rightCount);
+            counts.add(total);
+            if (total !== 1)
+                continue;
+            if (leftCount === 1 && rightCount === 0) {
+                for (const kind of left.singleKinds)
+                    singleKinds.add(kind);
+            }
+            if (leftCount === 0 && rightCount === 1) {
+                for (const kind of right.singleKinds)
+                    singleKinds.add(kind);
+            }
+        }
+    }
+    return {
+        counts,
+        singleKinds,
+        mayBlob: left.mayBlob || right.mayBlob,
+        mustBlob: left.mustBlob || right.mustBlob
+    };
+}
+function summarizePlanCarrier(node) {
+    switch (node.nodeKind) {
+        case "leaf":
+            if (node.blobEntryId)
+                return createCarrierSummary([0], [], true, true);
+            if (node.itemEntryId) {
+                return createCarrierSummary([1], [node.leaf.region === "dynamic" ? "object" : "string"]);
+            }
+            return createCarrierSummary([0]);
+        case "named":
+            return summarizePlanCarrier(node.target);
+        case "finite-domain":
+            if (node.blobEntryId)
+                return createCarrierSummary([0], [], true, true);
+            if (node.itemEntryId)
+                return createCarrierSummary([1], ["string"]);
+            return createCarrierSummary([0]);
+        case "array": {
+            if (node.extentStrategy === "blob-tail") {
+                return createCarrierSummary([0], [], true, false);
+            }
+            const elementSummary = summarizePlanCarrier(node.element);
+            const counts = new Set([0]);
+            const singleKinds = new Set();
+            if (elementSummary.counts.has(1)) {
+                counts.add(1);
+                for (const kind of elementSummary.singleKinds)
+                    singleKinds.add(kind);
+            }
+            if (elementSummary.counts.has(1) || elementSummary.counts.has(2)) {
+                counts.add(2);
+            }
+            return {
+                counts,
+                singleKinds,
+                mayBlob: true,
+                mustBlob: true
+            };
+        }
+        case "struct": {
+            let summary = createCarrierSummary([0]);
+            for (const field of node.fields) {
+                let fieldSummary = summarizePlanCarrier(field.node);
+                if (field.optional) {
+                    fieldSummary = addOptionalAbsence(fieldSummary);
+                }
+                if (field.presenceStrategy) {
+                    fieldSummary = {
+                        counts: new Set(fieldSummary.counts),
+                        singleKinds: new Set(fieldSummary.singleKinds),
+                        mayBlob: true,
+                        mustBlob: true
+                    };
+                }
+                summary = mergeCarrierSummaries(summary, fieldSummary);
+            }
+            return summary;
+        }
+    }
+}
+function inferDragDropCarrierKinds(plan) {
+    const summary = summarizePlanCarrier(plan.root);
+    const carriers = new Set();
+    const addNoBlobCarriers = () => {
+        if (summary.counts.has(0))
+            carriers.add("array");
+        if (summary.counts.has(1)) {
+            for (const kind of summary.singleKinds)
+                carriers.add(kind);
+        }
+        if (summary.counts.has(2))
+            carriers.add("array");
+    };
+    if (summary.mustBlob) {
+        if (summary.counts.has(0))
+            carriers.add("string");
+        if (summary.counts.has(1) || summary.counts.has(2))
+            carriers.add("array");
+    }
+    else {
+        addNoBlobCarriers();
+        if (summary.mayBlob) {
+            if (summary.counts.has(0))
+                carriers.add("string");
+            if (summary.counts.has(1) || summary.counts.has(2))
+                carriers.add("array");
+        }
+    }
+    return ["string", "array", "object"].filter((kind) => carriers.has(kind));
+}
+function collectDragDropPayloadHelpers(spec, cppTypes, cppCodecCatalog) {
+    const seen = new Set();
+    const helpers = [];
+    for (const service of spec.services) {
+        for (const member of service.members) {
+            if ((member.kind !== "DropTarget" && member.kind !== "HoverTarget") || !member.payloadTypeText)
+                continue;
+            const typeName = member.payloadTypeText.replace(/\s/g, "");
+            if (seen.has(typeName))
+                continue;
+            seen.add(typeName);
+            const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(cppCodecCatalog, service.name, member.name);
+            if (!payloadSite)
+                continue;
+            const plan = cppCodecCatalog.plansByCodecId.get(payloadSite.codecId);
+            if (!plan)
+                continue;
+            helpers.push({
+                typeName,
+                cppType: cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]),
+                codecId: payloadSite.codecId,
+                carriers: inferDragDropCarrierKinds(plan)
+            });
+        }
+    }
+    return helpers;
+}
+function collectTsDragDropPayloadHelpers(spec, codecCatalog) {
+    const seen = new Set();
+    const helpers = [];
+    for (const service of spec.services) {
+        for (const member of service.members) {
+            if ((member.kind !== "DropTarget" && member.kind !== "HoverTarget") || !member.payloadTypeText)
+                continue;
+            const typeName = member.payloadTypeText.replace(/\s/g, "");
+            if (seen.has(typeName))
+                continue;
+            seen.add(typeName);
+            const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(codecCatalog, service.name, member.name);
+            if (!payloadSite)
+                continue;
+            const plan = codecCatalog.plansByCodecId.get(payloadSite.codecId);
+            if (!plan)
+                continue;
+            helpers.push({
+                typeName,
+                tsType: mapTypeTextToTs(member.payloadTypeText),
+                codecId: payloadSite.codecId,
+                carriers: inferDragDropCarrierKinds(plan)
+            });
+        }
+    }
+    return helpers;
+}
+function renderTsDragDropPayloadHelpers(spec, codecCatalog) {
+    const helpers = collectTsDragDropPayloadHelpers(spec, codecCatalog);
+    return helpers
+        .map((helper) => {
+        const lines = [
+            `function decodeDragDropPayload_${helper.typeName}(rawPayload: unknown): ${helper.tsType} {`,
+            `  if (typeof rawPayload !== "string") {`,
+            `    throw new Error("Drag/drop payload must be tagged text.");`,
+            `  }`,
+            `  if (rawPayload.length === 0) {`,
+            `    throw new Error("Drag/drop payload is empty.");`,
+            `  }`,
+            `  const transportTag = rawPayload[0];`,
+            `  const payloadText = rawPayload.slice(1);`
+        ];
+        if (helper.carriers.includes("string")) {
+            lines.push(`  if (transportTag === "S") {`);
+            lines.push(`    return decode${helper.codecId}(payloadText);`);
+            lines.push(`  }`);
+        }
+        if (helper.carriers.includes("array")) {
+            lines.push(`  if (transportTag === "A") {`);
+            lines.push(`    const parsed = JSON.parse(payloadText) as unknown;`);
+            lines.push(`    if (!Array.isArray(parsed)) {`);
+            lines.push(`      throw new Error("Drag/drop payload must be a JSON array.");`);
+            lines.push(`    }`);
+            lines.push(`    return decode${helper.codecId}(parsed);`);
+            lines.push(`  }`);
+        }
+        if (helper.carriers.includes("object")) {
+            lines.push(`  if (transportTag === "O") {`);
+            lines.push(`    const parsed = JSON.parse(payloadText) as unknown;`);
+            lines.push(`    if (parsed === null || Array.isArray(parsed) || typeof parsed !== "object") {`);
+            lines.push(`      throw new Error("Drag/drop payload must be a JSON object.");`);
+            lines.push(`    }`);
+            lines.push(`    return decode${helper.codecId}(parsed);`);
+            lines.push(`  }`);
+        }
+        lines.push(`  throw new Error(\`Drag/drop payload has an unknown transport tag: \${transportTag}\`);`);
+        lines.push(`}`);
+        return lines.join("\n");
+    })
+        .join("\n\n");
+}
 function renderTypesHeader(spec, cppTypes) {
     const decls = cppTypes.orderedDecls.map(renderCppDecl).join("\n\n");
-    const metatypes = cppTypes.structNames
+    const metatypes = cppTypes.metatypeNames
         .flatMap((name) => [
         `Q_DECLARE_METATYPE(${spec.widgetName}::${name})`,
         `Q_DECLARE_METATYPE(QList<${spec.widgetName}::${name}>)`
@@ -663,6 +1149,7 @@ function renderTypesHeader(spec, cppTypes) {
     return `#pragma once
 #include <QString>
 #include <QStringList>
+#include <QByteArray>
 #include <QList>
 #include <QVariantMap>
 #include <QMetaType>
@@ -680,13 +1167,13 @@ ${metatypes}
 }
 function renderWidgetUmbrellaHeader(spec) {
     return `#pragma once
-// Built by <AnQst_version>
 #include "${spec.widgetName}Widget.h"
 #include "${spec.widgetName}Types.h"
 `;
 }
-function renderWidgetHeader(spec, cppTypes) {
+function renderWidgetHeader(spec, cppTypes, cppCodecCatalog) {
     const widgetClassName = `${spec.widgetName}Widget`;
+    const dragDropPayloadHelpers = collectDragDropPayloadHelpers(spec, cppTypes, cppCodecCatalog);
     const callbackAliases = [];
     const publicMethods = [];
     const slotMethods = [];
@@ -696,10 +1183,12 @@ function renderWidgetHeader(spec, cppTypes) {
     const properties = [];
     const fields = [];
     const publicSlots = [];
-    const bindings = [];
+    const dragDropHelperMethods = dragDropPayloadHelpers.flatMap((helper) => [
+        `static QByteArray encodeDragDropPayload_${helper.typeName}(const ${helper.cppType}& payload);`,
+        `static std::optional<${helper.cppType}> decodeDragDropPayload_${helper.typeName}(const QByteArray& rawPayload);`
+    ]);
     for (const service of spec.services) {
         for (const member of service.members) {
-            bindings.push({ service: service.name, member: member.name, kind: member.kind });
             const memberPascal = pascalCase(member.name);
             if (member.kind === "Call" && member.payloadTypeText) {
                 const cppType = cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]);
@@ -747,6 +1236,7 @@ function renderWidgetHeader(spec, cppTypes) {
         }
     }
     return `#pragma once
+#include <QByteArray>
 #include <QDateTime>
 #include <QHash>
 #include <QMetaMethod>
@@ -754,6 +1244,7 @@ function renderWidgetHeader(spec, cppTypes) {
 #include <QVariant>
 #include <QVariantList>
 #include <functional>
+#include <optional>
 #include "AnQstWebHostBase.h"
 #include "${spec.widgetName}Types.h"
 
@@ -784,6 +1275,7 @@ ${handleMethods.join("\n")}
     static constexpr const char* kBootstrapContentRoot = "qrc:/${spec.widgetName.toLowerCase()}";
     static constexpr const char* kBootstrapBridgeObject = "${spec.widgetName}Bridge";
     static constexpr int kMaxQueuedCallsPerEndpoint = 1024;
+${dragDropHelperMethods.map((s) => `    ${s}`).join("\n")}
 
     handle handle;
 ${publicMethods.map((s) => `    ${s}`).join("\n")}
@@ -806,13 +1298,6 @@ private:
         QVariantList args;
         QDateTime enqueuedAt;
     };
-    struct BridgeBindingRow {
-        const char* service;
-        const char* member;
-        const char* kind;
-    };
-    static const BridgeBindingRow kBridgeBindings[];
-    static constexpr int kBridgeBindingsCount = ${bindings.length};
     static QString makeBindingKey(const QString& service, const QString& member);
     void installBridgeBindings();
     bool hasEmitterListeners(const QString& service, const QString& member) const;
@@ -834,15 +1319,25 @@ ${fields.map((f) => `    ${f}`).join("\n")}
 };
 `;
 }
-function renderCppStub(spec, cppTypes) {
+function renderCppStub(spec, cppTypes, cppCodecCatalog) {
     const widgetClassName = `${spec.widgetName}Widget`;
+    const dragDropPayloadHelpers = collectDragDropPayloadHelpers(spec, cppTypes, cppCodecCatalog);
+    const cppCodecHelpers = (0, boundary_codecs_1.renderCppBoundaryCodecHelpers)(cppCodecCatalog, (typeText, pathHintParts) => cppTypes.mapTypeText(typeText, pathHintParts)).trim();
     const lines = [];
     lines.push(`#include "include/${spec.widgetName}Widget.h"`);
+    lines.push(`#include "AnQstBase93.h"`);
     lines.push(`#include <QDebug>`);
     lines.push(`#include <QElapsedTimer>`);
     lines.push(`#include <QEventLoop>`);
+    lines.push(`#include <QJsonArray>`);
+    lines.push(`#include <QJsonDocument>`);
+    lines.push(`#include <QJsonObject>`);
     lines.push(`#include <QMetaType>`);
     lines.push(`#include <QTimer>`);
+    lines.push(`#include <cstring>`);
+    lines.push(`#include <cstdint>`);
+    lines.push(`#include <string>`);
+    lines.push(`#include <vector>`);
     lines.push(`#include <stdexcept>`);
     lines.push("");
     lines.push(`using namespace ${spec.widgetName};`);
@@ -852,7 +1347,7 @@ function renderCppStub(spec, cppTypes) {
     lines.push("namespace {");
     lines.push("void registerGeneratedMetaTypes() {");
     lines.push("    static const bool registered = []() {");
-    for (const typeName of cppTypes.structNames) {
+    for (const typeName of cppTypes.metatypeNames) {
         lines.push(`        qRegisterMetaType<${spec.widgetName}::${typeName}>("${spec.widgetName}::${typeName}");`);
         lines.push(`        qRegisterMetaType<QList<${spec.widgetName}::${typeName}>>("QList<${spec.widgetName}::${typeName}>");`);
     }
@@ -860,8 +1355,89 @@ function renderCppStub(spec, cppTypes) {
     lines.push("    }();");
     lines.push("    Q_UNUSED(registered);");
     lines.push("}");
+    if (cppCodecHelpers.length > 0) {
+        lines.push("");
+        lines.push(cppCodecHelpers);
+    }
     lines.push("}");
     lines.push("");
+    for (const helper of dragDropPayloadHelpers) {
+        lines.push(`QByteArray ${widgetClassName}::encodeDragDropPayload_${helper.typeName}(const ${helper.cppType}& payload) {`);
+        lines.push(`    const QVariant wire = encode${helper.codecId}(payload);`);
+        if (helper.carriers.includes("string")) {
+            lines.push(`    if (wire.type() == QVariant::String) {`);
+            lines.push(`        QByteArray out;`);
+            lines.push(`        out.append('S');`);
+            lines.push(`        out.append(wire.toString().toUtf8());`);
+            lines.push(`        return out;`);
+            lines.push(`    }`);
+        }
+        if (helper.carriers.includes("array")) {
+            lines.push(`    if (wire.type() == QVariant::List) {`);
+            lines.push(`        QByteArray out;`);
+            lines.push(`        out.append('A');`);
+            lines.push(`        out.append(QJsonDocument(QJsonArray::fromVariantList(wire.toList())).toJson(QJsonDocument::Compact));`);
+            lines.push(`        return out;`);
+            lines.push(`    }`);
+        }
+        if (helper.carriers.includes("object")) {
+            lines.push(`    if (wire.type() == QVariant::Map) {`);
+            lines.push(`        QByteArray out;`);
+            lines.push(`        out.append('O');`);
+            lines.push(`        out.append(QJsonDocument(QJsonObject::fromVariantMap(wire.toMap())).toJson(QJsonDocument::Compact));`);
+            lines.push(`        return out;`);
+            lines.push(`    }`);
+        }
+        lines.push(`    throw std::runtime_error("AnQst drag/drop payload codec emitted an unsupported top-level carrier.");`);
+        lines.push(`}`);
+        lines.push("");
+        lines.push(`std::optional<${helper.cppType}> ${widgetClassName}::decodeDragDropPayload_${helper.typeName}(const QByteArray& rawPayload) {`);
+        lines.push(`    if (rawPayload.isEmpty()) {`);
+        lines.push(`        return std::nullopt;`);
+        lines.push(`    }`);
+        lines.push(`    const char transportTag = rawPayload.at(0);`);
+        lines.push(`    const QByteArray payloadBytes = rawPayload.mid(1);`);
+        if (helper.carriers.includes("string")) {
+            lines.push(`    if (transportTag == 'S') {`);
+            lines.push(`        try {`);
+            lines.push(`            return decode${helper.codecId}(QString::fromUtf8(payloadBytes));`);
+            lines.push(`        } catch (...) {`);
+            lines.push(`            return std::nullopt;`);
+            lines.push(`        }`);
+            lines.push(`    }`);
+        }
+        if (helper.carriers.includes("array")) {
+            lines.push(`    if (transportTag == 'A') {`);
+            lines.push(`        QJsonParseError parseError;`);
+            lines.push(`        const QJsonDocument document = QJsonDocument::fromJson(payloadBytes, &parseError);`);
+            lines.push(`        if (parseError.error != QJsonParseError::NoError || !document.isArray()) {`);
+            lines.push(`            return std::nullopt;`);
+            lines.push(`        }`);
+            lines.push(`        try {`);
+            lines.push(`            return decode${helper.codecId}(QVariant(document.array().toVariantList()));`);
+            lines.push(`        } catch (...) {`);
+            lines.push(`            return std::nullopt;`);
+            lines.push(`        }`);
+            lines.push(`    }`);
+        }
+        if (helper.carriers.includes("object")) {
+            lines.push(`    if (transportTag == 'O') {`);
+            lines.push(`        QJsonParseError parseError;`);
+            lines.push(`        const QJsonDocument document = QJsonDocument::fromJson(payloadBytes, &parseError);`);
+            lines.push(`        if (parseError.error != QJsonParseError::NoError || !document.isObject()) {`);
+            lines.push(`            return std::nullopt;`);
+            lines.push(`        }`);
+            lines.push(`        try {`);
+            lines.push(`            return decode${helper.codecId}(QVariant(document.object().toVariantMap()));`);
+            lines.push(`        } catch (...) {`);
+            lines.push(`            return std::nullopt;`);
+            lines.push(`        }`);
+            lines.push(`    }`);
+        }
+        lines.push(`    return std::nullopt;`);
+        lines.push(`}`);
+        lines.push("");
+    }
     for (const service of spec.services) {
         for (const member of service.members) {
             if (member.kind !== "Call" || !member.payloadTypeText)
@@ -878,14 +1454,6 @@ function renderCppStub(spec, cppTypes) {
             lines.push("");
         }
     }
-    lines.push(`const ${widgetClassName}::BridgeBindingRow ${widgetClassName}::kBridgeBindings[] = {`);
-    for (const service of spec.services) {
-        for (const member of service.members) {
-            lines.push(`    {"${service.name}", "${member.name}", "${member.kind}"},`);
-        }
-    }
-    lines.push(`};`);
-    lines.push("");
     lines.push(`${widgetClassName}::${widgetClassName}(QWidget* parent) : AnQstWebHostBase(parent), handle(this) {`);
     lines.push(`    static const bool kResourcesInitialized = []() {`);
     lines.push(`        ::qInitResources_${spec.widgetName}();`);
@@ -912,17 +1480,89 @@ function renderCppStub(spec, cppTypes) {
         for (const member of service.members) {
             if (member.kind === "DropTarget" && member.payloadTypeText) {
                 const cppType = cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]);
+                const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(cppCodecCatalog, service.name, member.name);
+                const typeName = member.payloadTypeText.replace(/\s/g, "");
                 lines.push(`    QObject::connect(this, &AnQstWebHostBase::anQstBridge_dropReceived, this, [this](const QString& service, const QString& member, const QVariant& payload, double x, double y) {`);
                 lines.push(`        if (service == QStringLiteral("${service.name}") && member == QStringLiteral("${member.name}")) {`);
-                lines.push(`            emit ${member.name}(payload.value<${cppType}>(), x, y);`);
+                if (payloadSite) {
+                    lines.push(`            if (payload.type() != QVariant::String) {`);
+                    lines.push(`                emitHostError(`);
+                    lines.push(`                    QStringLiteral("DeserializationError"),`);
+                    lines.push(`                    QStringLiteral("bridge"),`);
+                    lines.push(`                    QStringLiteral("error"),`);
+                    lines.push(`                    true,`);
+                    lines.push(`                    QStringLiteral("Failed to deserialize DropTarget ${service.name}.${member.name}."),`);
+                    lines.push(`                    {`);
+                    lines.push(`                        {QStringLiteral("service"), QStringLiteral("${service.name}")},`);
+                    lines.push(`                        {QStringLiteral("member"), QStringLiteral("${member.name}")},`);
+                    lines.push(`                        {QStringLiteral("detail"), QStringLiteral("Host did not provide tagged drag/drop payload text.")},`);
+                    lines.push(`                    });`);
+                    lines.push(`                return;`);
+                    lines.push(`            }`);
+                    lines.push(`            const auto decodedPayload = decodeDragDropPayload_${typeName}(payload.toString().toUtf8());`);
+                    lines.push(`            if (!decodedPayload.has_value()) {`);
+                    lines.push(`                emitHostError(`);
+                    lines.push(`                    QStringLiteral("DeserializationError"),`);
+                    lines.push(`                    QStringLiteral("bridge"),`);
+                    lines.push(`                    QStringLiteral("error"),`);
+                    lines.push(`                    true,`);
+                    lines.push(`                    QStringLiteral("Failed to deserialize DropTarget ${service.name}.${member.name}."),`);
+                    lines.push(`                    {`);
+                    lines.push(`                        {QStringLiteral("service"), QStringLiteral("${service.name}")},`);
+                    lines.push(`                        {QStringLiteral("member"), QStringLiteral("${member.name}")},`);
+                    lines.push(`                        {QStringLiteral("detail"), QStringLiteral("Tagged drag/drop payload did not match the planned boundary carrier.")},`);
+                    lines.push(`                    });`);
+                    lines.push(`                return;`);
+                    lines.push(`            }`);
+                    lines.push(`            emit ${member.name}(*decodedPayload, x, y);`);
+                }
+                else {
+                    lines.push(`            emit ${member.name}(payload.value<${cppType}>(), x, y);`);
+                }
                 lines.push(`        }`);
                 lines.push(`    });`);
             }
             else if (member.kind === "HoverTarget" && member.payloadTypeText) {
                 const cppType = cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]);
+                const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(cppCodecCatalog, service.name, member.name);
+                const typeName = member.payloadTypeText.replace(/\s/g, "");
                 lines.push(`    QObject::connect(this, &AnQstWebHostBase::anQstBridge_hoverUpdated, this, [this](const QString& service, const QString& member, const QVariant& payload, double x, double y) {`);
                 lines.push(`        if (service == QStringLiteral("${service.name}") && member == QStringLiteral("${member.name}")) {`);
-                lines.push(`            emit ${member.name}(payload.value<${cppType}>(), x, y);`);
+                if (payloadSite) {
+                    lines.push(`            if (payload.type() != QVariant::String) {`);
+                    lines.push(`                emitHostError(`);
+                    lines.push(`                    QStringLiteral("DeserializationError"),`);
+                    lines.push(`                    QStringLiteral("bridge"),`);
+                    lines.push(`                    QStringLiteral("error"),`);
+                    lines.push(`                    true,`);
+                    lines.push(`                    QStringLiteral("Failed to deserialize HoverTarget ${service.name}.${member.name}."),`);
+                    lines.push(`                    {`);
+                    lines.push(`                        {QStringLiteral("service"), QStringLiteral("${service.name}")},`);
+                    lines.push(`                        {QStringLiteral("member"), QStringLiteral("${member.name}")},`);
+                    lines.push(`                        {QStringLiteral("detail"), QStringLiteral("Host did not provide tagged drag/drop payload text.")},`);
+                    lines.push(`                    });`);
+                    lines.push(`                return;`);
+                    lines.push(`            }`);
+                    lines.push(`            const auto decodedPayload = decodeDragDropPayload_${typeName}(payload.toString().toUtf8());`);
+                    lines.push(`            if (!decodedPayload.has_value()) {`);
+                    lines.push(`                emitHostError(`);
+                    lines.push(`                    QStringLiteral("DeserializationError"),`);
+                    lines.push(`                    QStringLiteral("bridge"),`);
+                    lines.push(`                    QStringLiteral("error"),`);
+                    lines.push(`                    true,`);
+                    lines.push(`                    QStringLiteral("Failed to deserialize HoverTarget ${service.name}.${member.name}."),`);
+                    lines.push(`                    {`);
+                    lines.push(`                        {QStringLiteral("service"), QStringLiteral("${service.name}")},`);
+                    lines.push(`                        {QStringLiteral("member"), QStringLiteral("${member.name}")},`);
+                    lines.push(`                        {QStringLiteral("detail"), QStringLiteral("Tagged drag/drop payload did not match the planned boundary carrier.")},`);
+                    lines.push(`                    });`);
+                    lines.push(`                return;`);
+                    lines.push(`            }`);
+                    lines.push(`            emit ${member.name}(*decodedPayload, x, y);`);
+                }
+                else {
+                    lines.push(`            emit ${member.name}(payload.value<${cppType}>(), x, y);`);
+                }
                 lines.push(`        }`);
                 lines.push(`    });`);
                 lines.push(`    QObject::connect(this, &AnQstWebHostBase::anQstBridge_hoverLeft, this, [this](const QString& service, const QString& member) {`);
@@ -1028,11 +1668,13 @@ function renderCppStub(spec, cppTypes) {
                 continue;
             const timeoutMs = member.timeoutMs;
             const cppType = cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]);
+            const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(cppCodecCatalog, service.name, member.name);
             lines.push(`    if (service == QStringLiteral("${service.name}") && member == QStringLiteral("${member.name}")) {`);
             for (let i = 0; i < member.parameters.length; i++) {
                 const p = member.parameters[i];
                 const pType = cppTypes.mapTypeText(p.typeText, [service.name, member.name, p.name]);
-                lines.push(`        const ${pType} ${p.name} = ${variantToCppExpression(pType, `args.value(${i})`)};`);
+                const paramSite = (0, boundary_codecs_1.getBoundaryParameterSite)(cppCodecCatalog, service.name, member.name, p.name);
+                lines.push(`        const ${pType} ${p.name} = ${paramSite ? `decode${paramSite.codecId}(args.value(${i}))` : variantToCppExpression(pType, `args.value(${i})`)};`);
             }
             lines.push(`        const QString requestId = QStringLiteral("call-%1").arg(++m_callRequestCounter);`);
             lines.push(`        const QString queueKey = makeBindingKey(QStringLiteral("${service.name}"), QStringLiteral("${member.name}"));`);
@@ -1049,7 +1691,7 @@ function renderCppStub(spec, cppTypes) {
             lines.push(`            try {`);
             const callArgs = member.parameters.map((p) => p.name).join(", ");
             lines.push(`                const ${cppType} result = m_${member.name}Handler(${callArgs});`);
-            lines.push(`                return ${cppToVariantExpression(cppType, "result")};`);
+            lines.push(`                return ${payloadSite ? `encode${payloadSite.codecId}(result)` : cppToVariantExpression(cppType, "result")};`);
             lines.push(`            } catch (const std::exception& ex) {`);
             lines.push(`                return QVariantMap{`);
             lines.push(`                    {QStringLiteral("code"), QStringLiteral("CallHandlerError")},`);
@@ -1101,7 +1743,8 @@ function renderCppStub(spec, cppTypes) {
             for (let i = 0; i < member.parameters.length; i++) {
                 const p = member.parameters[i];
                 const pType = cppTypes.mapTypeText(p.typeText, [service.name, member.name, p.name]);
-                lines.push(`        const ${pType} ${p.name} = ${variantToCppExpression(pType, `args.value(${i})`)};`);
+                const paramSite = (0, boundary_codecs_1.getBoundaryParameterSite)(cppCodecCatalog, service.name, member.name, p.name);
+                lines.push(`        const ${pType} ${p.name} = ${paramSite ? `decode${paramSite.codecId}(args.value(${i}))` : variantToCppExpression(pType, `args.value(${i})`)};`);
             }
             const argNames = member.parameters.map((p) => p.name).join(", ");
             lines.push(`        emit ${member.name}(${argNames});`);
@@ -1117,8 +1760,9 @@ function renderCppStub(spec, cppTypes) {
             if (member.kind !== "Input" || !member.payloadTypeText)
                 continue;
             const cppType = cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]);
+            const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(cppCodecCatalog, service.name, member.name);
             lines.push(`    if (service == QStringLiteral("${service.name}") && member == QStringLiteral("${member.name}")) {`);
-            lines.push(`        const ${cppType} typedValue = ${variantToCppExpression(cppType, "value")};`);
+            lines.push(`        const ${cppType} typedValue = ${payloadSite ? `decode${payloadSite.codecId}(value)` : variantToCppExpression(cppType, "value")};`);
             lines.push(`        set${pascalCase(member.name)}(typedValue);`);
             lines.push(`        if (m_${member.name}Handler) m_${member.name}Handler(typedValue);`);
             lines.push(`        return;`);
@@ -1138,12 +1782,14 @@ function renderCppStub(spec, cppTypes) {
             }
             if (member.kind === "Slot") {
                 const ret = member.payloadTypeText ? cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]) : "void";
+                const payloadSite = member.payloadTypeText ? (0, boundary_codecs_1.getBoundaryPayloadSite)(cppCodecCatalog, service.name, member.name) : undefined;
                 const args = member.parameters.map((p) => `${cppTypes.mapTypeText(p.typeText, [service.name, member.name, p.name])} ${p.name}`).join(", ");
                 lines.push(`${ret} ${widgetClassName}::slot_${member.name}(${args}) {`);
                 lines.push(`    QVariantList invokeArgs;`);
                 for (const p of member.parameters) {
                     const pType = mapTsTypeToCpp(p.typeText);
-                    lines.push(`    invokeArgs.push_back(${cppToVariantExpression(pType, p.name)});`);
+                    const paramSite = (0, boundary_codecs_1.getBoundaryParameterSite)(cppCodecCatalog, service.name, member.name, p.name);
+                    lines.push(`    invokeArgs.push_back(${paramSite ? `encode${paramSite.codecId}(${p.name})` : cppToVariantExpression(pType, p.name)});`);
                 }
                 lines.push(`    QVariant result;`);
                 lines.push(`    QString invokeError;`);
@@ -1160,13 +1806,14 @@ function renderCppStub(spec, cppTypes) {
                     lines.push(`    return;`);
                 }
                 else {
-                    lines.push(`    return ${variantToCppExpression(ret, "result")};`);
+                    lines.push(`    return ${payloadSite ? `decode${payloadSite.codecId}(result)` : variantToCppExpression(ret, "result")};`);
                 }
                 lines.push("}");
                 lines.push("");
             }
             else if ((member.kind === "Input" || member.kind === "Output") && member.payloadTypeText) {
                 const cppType = cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]);
+                const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(cppCodecCatalog, service.name, member.name);
                 const cap = member.name.charAt(0).toUpperCase() + member.name.slice(1);
                 lines.push(`${cppType} ${widgetClassName}::${member.name}() const {`);
                 lines.push(`    return m_${member.name};`);
@@ -1174,9 +1821,40 @@ function renderCppStub(spec, cppTypes) {
                 lines.push("");
                 lines.push(`void ${widgetClassName}::set${cap}(const ${cppType}& value) {`);
                 lines.push(`    if (m_${member.name} == value) return;`);
+                if (member.kind === "Output") {
+                    lines.push(`    QVariant encodedValue;`);
+                    lines.push(`    try {`);
+                    lines.push(`        encodedValue = ${payloadSite ? `encode${payloadSite.codecId}(value)` : cppToVariantExpression(cppType, "value")};`);
+                    lines.push(`    } catch (const std::exception& ex) {`);
+                    lines.push(`        emitHostError(`);
+                    lines.push(`            QStringLiteral("SerializationError"),`);
+                    lines.push(`            QStringLiteral("bridge"),`);
+                    lines.push(`            QStringLiteral("error"),`);
+                    lines.push(`            true,`);
+                    lines.push(`            QStringLiteral("Failed to serialize Output ${service.name}.${member.name}."),`);
+                    lines.push(`            {`);
+                    lines.push(`                {QStringLiteral("service"), QStringLiteral("${service.name}")},`);
+                    lines.push(`                {QStringLiteral("member"), QStringLiteral("${member.name}")},`);
+                    lines.push(`                {QStringLiteral("detail"), QString::fromUtf8(ex.what())},`);
+                    lines.push(`            });`);
+                    lines.push(`        return;`);
+                    lines.push(`    } catch (...) {`);
+                    lines.push(`        emitHostError(`);
+                    lines.push(`            QStringLiteral("SerializationError"),`);
+                    lines.push(`            QStringLiteral("bridge"),`);
+                    lines.push(`            QStringLiteral("error"),`);
+                    lines.push(`            true,`);
+                    lines.push(`            QStringLiteral("Failed to serialize Output ${service.name}.${member.name}."),`);
+                    lines.push(`            {`);
+                    lines.push(`                {QStringLiteral("service"), QStringLiteral("${service.name}")},`);
+                    lines.push(`                {QStringLiteral("member"), QStringLiteral("${member.name}")},`);
+                    lines.push(`            });`);
+                    lines.push(`        return;`);
+                    lines.push(`    }`);
+                }
                 lines.push(`    m_${member.name} = value;`);
                 if (member.kind === "Output") {
-                    lines.push(`    setOutputValue(QStringLiteral("${service.name}"), QStringLiteral("${member.name}"), ${cppToVariantExpression(cppType, "value")});`);
+                    lines.push(`    setOutputValue(QStringLiteral("${service.name}"), QStringLiteral("${member.name}"), encodedValue);`);
                 }
                 lines.push(`    emit ${member.name}Changed(value);`);
                 lines.push("}");
@@ -1363,59 +2041,144 @@ function slotHandlerReturnType(tsRet) {
     }
     return `${tsRet} | Promise<${tsRet}> | Error`;
 }
-function renderTsService(spec, serviceName) {
+function renderTsService(spec, serviceName, codecCatalog) {
     const members = spec.services.find((s) => s.name === serviceName)?.members ?? [];
     const fieldLines = [];
     const methodLines = [];
     const setMembers = [];
     const onSlotMembers = [];
     const constructorBodyLines = [];
-    constructorBodyLines.push("    this._bridge.ready().catch((error) => console.error('AnQst bridge ready() failed', error, (error as { stack?: unknown })?.stack));");
     for (const m of members) {
         const args = m.parameters.map((p) => `${p.name}: ${mapTypeTextToTs(p.typeText)}`).join(", ");
-        const valueArgs = m.parameters.map((p) => p.name).join(", ");
-        const valueArray = valueArgs.length > 0 ? `[${valueArgs}]` : "[]";
+        const paramSites = m.parameters.map((p) => (0, boundary_codecs_1.getBoundaryParameterSite)(codecCatalog, serviceName, m.name, p.name));
+        const encodedValueArray = paramSites.length > 0
+            ? `[${m.parameters.map((p, index) => `${paramSites[index] ? `encode${paramSites[index].codecId}(${p.name})` : p.name}`).join(", ")}]`
+            : "[]";
+        const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(codecCatalog, serviceName, m.name);
         if (m.kind === "Call") {
             const ret = mapTypeTextToTs(m.payloadTypeText ?? "void");
-            methodLines.push(`  async ${m.name}(${args}): Promise<${ret}> { return this._bridge.call<${ret}>("${serviceName}", "${m.name}", ${valueArray}); }`);
+            if (payloadSite) {
+                methodLines.push(`  async ${m.name}(${args}): Promise<${ret}> { const result = await this._bridge.call<unknown>("${serviceName}", "${m.name}", ${encodedValueArray}); return decode${payloadSite.codecId}(result); }`);
+            }
+            else {
+                methodLines.push(`  async ${m.name}(${args}): Promise<${ret}> { return this._bridge.call<${ret}>("${serviceName}", "${m.name}", ${encodedValueArray}); }`);
+            }
             continue;
         }
         if (m.kind === "Emitter") {
-            methodLines.push(`  ${m.name}(${args}): void { this._bridge.emit("${serviceName}", "${m.name}", ${valueArray}); }`);
+            methodLines.push(`  ${m.name}(${args}): void {`);
+            methodLines.push(`    let encodedArgs: unknown[];`);
+            methodLines.push(`    try {`);
+            methodLines.push(`      encodedArgs = ${encodedValueArray};`);
+            methodLines.push(`    } catch (error) {`);
+            methodLines.push(`      this._bridge.reportFrontendDiagnostic({`);
+            methodLines.push(`        code: "SerializationError",`);
+            methodLines.push(`        severity: "error",`);
+            methodLines.push(`        category: "bridge",`);
+            methodLines.push(`        recoverable: true,`);
+            methodLines.push(`        message: \`Failed to serialize Emitter ${serviceName}.${m.name}: \${errorMessage(error)}\`,`);
+            methodLines.push(`        service: "${serviceName}",`);
+            methodLines.push(`        member: "${m.name}",`);
+            methodLines.push(`        context: { interaction: "Emitter" }`);
+            methodLines.push(`      });`);
+            methodLines.push(`      return;`);
+            methodLines.push(`    }`);
+            methodLines.push(`    this._bridge.emit("${serviceName}", "${m.name}", encodedArgs);`);
+            methodLines.push(`  }`);
             continue;
         }
         if (m.kind === "Slot") {
             const ret = mapTypeTextToTs(m.payloadTypeText ?? "void");
+            const decodedArgs = m.parameters.map((p, index) => `${paramSites[index] ? `decode${paramSites[index].codecId}(wireArgs[${index}])` : `wireArgs[${index}] as ${mapTypeTextToTs(p.typeText)}`}`).join(", ");
             onSlotMembers.push(`    ${m.name}: (handler: (${args}) => ${slotHandlerReturnType(ret)}): void => {`);
-            onSlotMembers.push(`      this._bridge.registerSlot("${serviceName}", "${m.name}", handler as (...args: unknown[]) => unknown);`);
+            onSlotMembers.push(`      this._bridge.registerSlot("${serviceName}", "${m.name}", (...wireArgs: unknown[]) => {`);
+            onSlotMembers.push(`        const result = handler(${decodedArgs});`);
+            if (payloadSite) {
+                onSlotMembers.push(`        if (result instanceof Promise) return result.then((value) => value instanceof Error ? value : encode${payloadSite.codecId}(value));`);
+                onSlotMembers.push(`        return result instanceof Error ? result : encode${payloadSite.codecId}(result);`);
+            }
+            else {
+                onSlotMembers.push("        return result;");
+            }
+            onSlotMembers.push("      });");
             onSlotMembers.push("    },");
             continue;
         }
         if ((m.kind === "Input" || m.kind === "Output") && m.payloadTypeText) {
             const tsType = mapTypeTextToTs(m.payloadTypeText);
-            fieldLines.push(`  private readonly _${m.name} = signal<${tsType}>((undefined as unknown) as ${tsType});`);
-            methodLines.push(`  ${m.name}(): ${tsType} { return this._${m.name}(); }`);
+            fieldLines.push(`  private readonly _${m.name} = signal<${tsType} | undefined>(undefined);`);
+            methodLines.push(`  ${m.name}(): ${tsType} | undefined { return this._${m.name}(); }`);
             if (m.kind === "Input") {
                 setMembers.push(`    ${m.name}: (value: ${tsType}): void => {`);
+                setMembers.push(`      let encodedValue: unknown;`);
+                setMembers.push(`      try {`);
+                setMembers.push(`        encodedValue = ${payloadSite ? `encode${payloadSite.codecId}(value)` : "value"};`);
+                setMembers.push(`      } catch (error) {`);
+                setMembers.push(`        this._bridge.reportFrontendDiagnostic({`);
+                setMembers.push(`          code: "SerializationError",`);
+                setMembers.push(`          severity: "error",`);
+                setMembers.push(`          category: "bridge",`);
+                setMembers.push(`          recoverable: true,`);
+                setMembers.push(`          message: \`Failed to serialize Input ${serviceName}.${m.name}: \${errorMessage(error)}\`,`);
+                setMembers.push(`          service: "${serviceName}",`);
+                setMembers.push(`          member: "${m.name}",`);
+                setMembers.push(`          context: { interaction: "Input" }`);
+                setMembers.push(`        });`);
+                setMembers.push(`        return;`);
+                setMembers.push(`      }`);
                 setMembers.push(`      this._${m.name}.set(value);`);
-                setMembers.push(`      this._bridge.setInput("${serviceName}", "${m.name}", value);`);
+                setMembers.push(`      this._bridge.setInput("${serviceName}", "${m.name}", encodedValue);`);
                 setMembers.push("    },");
             }
             if (m.kind === "Output") {
-                constructorBodyLines.push(`    this._bridge.onOutput("${serviceName}", "${m.name}", (value) => this._${m.name}.set(value as ${tsType}));`);
+                constructorBodyLines.push(`    this._bridge.onOutput("${serviceName}", "${m.name}", (value) => {`);
+                constructorBodyLines.push(`      this._${m.name}.set(${payloadSite ? `decode${payloadSite.codecId}(value)` : `value as ${tsType}`});`);
+                constructorBodyLines.push(`    });`);
             }
         }
         if (m.kind === "DropTarget" && m.payloadTypeText) {
             const tsType = mapTypeTextToTs(m.payloadTypeText);
+            const typeName = m.payloadTypeText.replace(/\s/g, "");
             fieldLines.push(`  private readonly _${m.name} = signal<{ payload: ${tsType}; x: number; y: number } | null>(null);`);
             methodLines.push(`  ${m.name}(): { payload: ${tsType}; x: number; y: number } | null { return this._${m.name}(); }`);
-            constructorBodyLines.push(`    this._bridge.onDrop("${serviceName}", "${m.name}", (payload, x, y) => this._${m.name}.set({ payload: payload as ${tsType}, x, y }));`);
+            constructorBodyLines.push(`    this._bridge.onDrop("${serviceName}", "${m.name}", (payload, x, y) => {`);
+            constructorBodyLines.push(`      try {`);
+            constructorBodyLines.push(`        this._${m.name}.set({ payload: ${payloadSite ? `decodeDragDropPayload_${typeName}(payload)` : `payload as ${tsType}`}, x, y });`);
+            constructorBodyLines.push(`      } catch (error) {`);
+            constructorBodyLines.push(`        this._bridge.reportFrontendDiagnostic({`);
+            constructorBodyLines.push(`          code: "DeserializationError",`);
+            constructorBodyLines.push(`          severity: "error",`);
+            constructorBodyLines.push(`          category: "bridge",`);
+            constructorBodyLines.push(`          recoverable: true,`);
+            constructorBodyLines.push(`          message: \`Failed to deserialize DropTarget ${serviceName}.${m.name}: \${errorMessage(error)}\`,`);
+            constructorBodyLines.push(`          service: "${serviceName}",`);
+            constructorBodyLines.push(`          member: "${m.name}",`);
+            constructorBodyLines.push(`          context: { interaction: "DropTarget" }`);
+            constructorBodyLines.push(`        });`);
+            constructorBodyLines.push(`      }`);
+            constructorBodyLines.push(`    });`);
         }
         if (m.kind === "HoverTarget" && m.payloadTypeText) {
             const tsType = mapTypeTextToTs(m.payloadTypeText);
+            const typeName = m.payloadTypeText.replace(/\s/g, "");
             fieldLines.push(`  private readonly _${m.name} = signal<{ payload: ${tsType}; x: number; y: number } | null>(null);`);
             methodLines.push(`  ${m.name}(): { payload: ${tsType}; x: number; y: number } | null { return this._${m.name}(); }`);
-            constructorBodyLines.push(`    this._bridge.onHover("${serviceName}", "${m.name}", (payload, x, y) => this._${m.name}.set({ payload: payload as ${tsType}, x, y }));`);
+            constructorBodyLines.push(`    this._bridge.onHover("${serviceName}", "${m.name}", (payload, x, y) => {`);
+            constructorBodyLines.push(`      try {`);
+            constructorBodyLines.push(`        this._${m.name}.set({ payload: ${payloadSite ? `decodeDragDropPayload_${typeName}(payload)` : `payload as ${tsType}`}, x, y });`);
+            constructorBodyLines.push(`      } catch (error) {`);
+            constructorBodyLines.push(`        this._bridge.reportFrontendDiagnostic({`);
+            constructorBodyLines.push(`          code: "DeserializationError",`);
+            constructorBodyLines.push(`          severity: "error",`);
+            constructorBodyLines.push(`          category: "bridge",`);
+            constructorBodyLines.push(`          recoverable: true,`);
+            constructorBodyLines.push(`          message: \`Failed to deserialize HoverTarget ${serviceName}.${m.name}: \${errorMessage(error)}\`,`);
+            constructorBodyLines.push(`          service: "${serviceName}",`);
+            constructorBodyLines.push(`          member: "${m.name}",`);
+            constructorBodyLines.push(`          context: { interaction: "HoverTarget" }`);
+            constructorBodyLines.push(`        });`);
+            constructorBodyLines.push(`      }`);
+            constructorBodyLines.push(`    });`);
             constructorBodyLines.push(`    this._bridge.onHoverLeft("${serviceName}", "${m.name}", () => this._${m.name}.set(null));`);
         }
     }
@@ -1464,7 +2227,7 @@ function renderTsServiceDts(spec, serviceName) {
         }
         if ((m.kind === "Input" || m.kind === "Output") && m.payloadTypeText) {
             const tsType = mapTypeTextToTs(m.payloadTypeText);
-            classMembers.push(`  ${m.name}(): ${tsType};`);
+            classMembers.push(`  ${m.name}(): ${tsType} | undefined;`);
             if (m.kind === "Input") {
                 setMembers.push(`  ${m.name}(value: ${tsType}): void;`);
             }
@@ -1494,15 +2257,21 @@ export declare class ${serviceName} {
   readonly onSlot: ${onSlotInterfaceName};${classMemberBlock}
 }`;
 }
-function renderTsServices(spec) {
-    const serviceClasses = spec.services.map((s) => renderTsService(spec, s.name)).join("\n");
+function renderTsServices(spec, codecCatalog) {
+    const serviceClasses = spec.services.map((s) => renderTsService(spec, s.name, codecCatalog)).join("\n");
     const externalTypeImports = renderRequiredTypeImports(spec, `frontend/${(0, layout_1.generatedFrontendDirName)(spec.widgetName)}/services.ts`).trim();
     const localTypeImports = renderLocalTypeImports(spec).trim();
     const typeImports = [externalTypeImports, localTypeImports].filter((s) => s.length > 0).join("\n");
     const typeImportsBlock = typeImports.length > 0 ? `${typeImports}\n\n` : "";
+    const dragDropHelperBlock = renderTsDragDropPayloadHelpers(spec, codecCatalog).trim();
+    const dragDropHelpers = dragDropHelperBlock.length > 0 ? `\n// Drag/drop payload helpers\n${dragDropHelperBlock}\n` : "";
     return `import { Injectable, inject, signal } from "@angular/core";
 ${typeImportsBlock}
 
+// Boundary codec plan helpers
+${(0, boundary_codecs_1.renderTsBoundaryCodecHelpers)(codecCatalog)}
+${dragDropHelpers}
+
 type SlotHandler = (...args: unknown[]) => unknown;
 type OutputHandler = (value: unknown) => void;
 type SlotInvocationListener = (requestId: string, service: string, member: string, args: unknown[]) => void;
@@ -1510,6 +2279,28 @@ type OutputListener = (service: string, member: string, value: unknown) => void;
 type DropListener = (service: string, member: string, payload: unknown, x: number, y: number) => void;
 type HoverListener = (service: string, member: string, payload: unknown, x: number, y: number) => void;
 type HoverLeftListener = (service: string, member: string) => void;
+type HostDiagnosticListener = (payload: unknown) => void;
+type DisconnectListener = () => void;
+
+export type AnQstBridgeSeverity = "info" | "warn" | "error" | "fatal";
+export type AnQstBridgeSource = "frontend" | "host";
+export type AnQstBridgeTransport = "qt-webchannel" | "dev-websocket";
+export type AnQstBridgeState = "starting" | "ready" | "failed" | "disconnected";
+
+export interface AnQstBridgeDiagnostic {
+  code: string;
+  severity: AnQstBridgeSeverity;
+  category: string;
+  recoverable: boolean;
+  message: string;
+  timestamp: string;
+  source: AnQstBridgeSource;
+  transport?: AnQstBridgeTransport;
+  service?: string;
+  member?: string;
+  requestId?: string;
+  context?: Record<string, unknown>;
+}
 
 interface HostBridgeApi {
   anQstBridge_call(service: string, member: string, args: unknown[], callback: (result: unknown) => void): void;
@@ -1521,6 +2312,7 @@ interface HostBridgeApi {
   anQstBridge_slotInvocationRequested: {
     connect: (cb: (requestId: string, service: string, member: string, args: unknown[]) => void) => void;
   };
+  anQstBridge_hostDiagnostic?: { connect: (cb: (payload: unknown) => void) => void };
   anQstBridge_dropReceived: { connect: (cb: (service: string, member: string, payload: unknown, x: number, y: number) => void) => void };
   anQstBridge_hoverUpdated: { connect: (cb: (service: string, member: string, payload: unknown, x: number, y: number) => void) => void };
   anQstBridge_hoverLeft: { connect: (cb: (service: string, member: string) => void) => void };
@@ -1534,6 +2326,7 @@ interface QWebChannelCtor {
 }
 
 interface BridgeAdapter {
+  readonly transport: AnQstBridgeTransport;
   call<T>(service: string, member: string, args: unknown[]): Promise<T>;
   emit(service: string, member: string, args: unknown[]): void;
   setInput(service: string, member: string, value: unknown): void;
@@ -1541,11 +2334,82 @@ interface BridgeAdapter {
   resolveSlot(requestId: string, ok: boolean, payload: unknown, error: string): void;
   onOutput(handler: OutputListener): void;
   onSlotInvocation(handler: SlotInvocationListener): void;
+  onHostDiagnostic(handler: HostDiagnosticListener): void;
+  onDisconnected(handler: DisconnectListener): void;
   onDrop(handler: DropListener): void;
   onHover(handler: HoverListener): void;
   onHoverLeft(handler: HoverLeftListener): void;
 }
 
+function errorMessage(error: unknown): string {
+  if (error instanceof Error && typeof error.message === "string" && error.message.length > 0) {
+    return error.message;
+  }
+  return String(error);
+}
+
+function normalizeSeverity(value: unknown): AnQstBridgeSeverity {
+  if (value === "info" || value === "warn" || value === "error" || value === "fatal") {
+    return value;
+  }
+  return "error";
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  if (value === null || typeof value !== "object") {
+    return undefined;
+  }
+  return value as Record<string, unknown>;
+}
+
+function readString(record: Record<string, unknown> | undefined, key: string): string | undefined {
+  const value = record?.[key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function readBoolean(record: Record<string, unknown> | undefined, key: string): boolean | undefined {
+  const value = record?.[key];
+  return typeof value === "boolean" ? value : undefined;
+}
+
+function readContext(record: Record<string, unknown> | undefined): Record<string, unknown> | undefined {
+  const context = asRecord(record?.["context"]);
+  return context === undefined ? undefined : context;
+}
+
+function normalizeHostDiagnostic(
+  payload: unknown,
+  transport: AnQstBridgeTransport
+): Omit<AnQstBridgeDiagnostic, "timestamp"> {
+  const row = asRecord(payload);
+  if (row === undefined) {
+    return {
+      code: "HostDiagnosticMalformed",
+      severity: "error",
+      category: "bridge",
+      recoverable: true,
+      message: "Host emitted a malformed diagnostic payload.",
+      source: "host",
+      transport
+    };
+  }
+
+  const context = readContext(row);
+  return {
+    code: readString(row, "code") ?? "HostDiagnostic",
+    severity: normalizeSeverity(row["severity"]),
+    category: readString(row, "category") ?? "bridge",
+    recoverable: readBoolean(row, "recoverable") ?? true,
+    message: readString(row, "message") ?? "Host emitted a diagnostic payload.",
+    source: "host",
+    transport,
+    service: readString(row, "service") ?? readString(context, "service"),
+    member: readString(row, "member") ?? readString(context, "member"),
+    requestId: readString(row, "requestId") ?? readString(context, "requestId"),
+    context
+  };
+}
+
 function isBridgeCallError(value: unknown): value is {
   code: unknown;
   message: unknown;
@@ -1565,6 +2429,8 @@ function isBridgeCallError(value: unknown): value is {
 }
 
 class QtWebChannelAdapter implements BridgeAdapter {
+  readonly transport = "qt-webchannel" as const;
+
   private constructor(private readonly host: HostBridgeApi) {}
 
   static async create(): Promise<QtWebChannelAdapter> {
@@ -1632,6 +2498,14 @@ class QtWebChannelAdapter implements BridgeAdapter {
     this.host.anQstBridge_slotInvocationRequested.connect(handler);
   }
 
+  onHostDiagnostic(handler: HostDiagnosticListener): void {
+    this.host.anQstBridge_hostDiagnostic?.connect(handler);
+  }
+
+  onDisconnected(_handler: DisconnectListener): void {
+    // QWebChannel does not expose a deterministic disconnect event here.
+  }
+
   onDrop(handler: DropListener): void {
     this.host.anQstBridge_dropReceived.connect(handler);
   }
@@ -1646,6 +2520,7 @@ class QtWebChannelAdapter implements BridgeAdapter {
 }
 
 class WebSocketBridgeAdapter implements BridgeAdapter {
+  readonly transport = "dev-websocket" as const;
   private readonly pending = new Map<string, {
     service: string;
     member: string;
@@ -1655,6 +2530,8 @@ class WebSocketBridgeAdapter implements BridgeAdapter {
   }>();
   private readonly outputListeners: OutputListener[] = [];
   private readonly slotListeners: SlotInvocationListener[] = [];
+  private readonly hostDiagnosticListeners: HostDiagnosticListener[] = [];
+  private readonly disconnectListeners: DisconnectListener[] = [];
   private readonly dropListeners: DropListener[] = [];
   private readonly hoverListeners: HoverListener[] = [];
   private readonly hoverLeftListeners: HoverLeftListener[] = [];
@@ -1726,7 +2603,9 @@ class WebSocketBridgeAdapter implements BridgeAdapter {
         return;
       }
       if (type === "hostError") {
-        console.error("AnQst host error:", message["payload"]);
+        for (const listener of this.hostDiagnosticListeners) {
+          listener(message["payload"]);
+        }
         return;
       }
       if (type === "widgetReattached") {
@@ -1745,6 +2624,9 @@ class WebSocketBridgeAdapter implements BridgeAdapter {
         });
       }
       this.pending.clear();
+      for (const listener of this.disconnectListeners) {
+        listener();
+      }
     });
   }
 
@@ -1813,6 +2695,14 @@ class WebSocketBridgeAdapter implements BridgeAdapter {
     this.slotListeners.push(handler);
   }
 
+  onHostDiagnostic(handler: HostDiagnosticListener): void {
+    this.hostDiagnosticListeners.push(handler);
+  }
+
+  onDisconnected(handler: DisconnectListener): void {
+    this.disconnectListeners.push(handler);
+  }
+
   onDrop(handler: DropListener): void {
     this.dropListeners.push(handler);
   }
@@ -1828,53 +2718,116 @@ class WebSocketBridgeAdapter implements BridgeAdapter {
 
 @Injectable({ providedIn: "root" })
 class AnQstBridgeRuntime {
+  private static readonly maxDiagnostics = 50;
   private adapter: BridgeAdapter | null = null;
   private readonly slotHandlers = new Map<string, SlotHandler>();
   private readonly outputHandlers = new Map<string, OutputHandler[]>();
   private readonly dropHandlers = new Map<string, ((payload: unknown, x: number, y: number) => void)[]>();
   private readonly hoverHandlers = new Map<string, ((payload: unknown, x: number, y: number) => void)[]>();
   private readonly hoverLeftHandlers = new Map<string, (() => void)[]>();
-  private readonly startup = this.init();
+  private readonly diagnosticListeners = new Set<(diagnostic: AnQstBridgeDiagnostic) => void>();
+  private readonly _diagnostics = signal<readonly AnQstBridgeDiagnostic[]>([]);
+  private readonly _state = signal<AnQstBridgeState>("starting");
+  private readonly startup = this.init().catch((error) => {
+    this._state.set("failed");
+    this.reportFrontendDiagnostic({
+      code: "BridgeBootstrapError",
+      severity: "fatal",
+      category: "bridge",
+      recoverable: false,
+      message: \`Failed to initialize bridge: \${errorMessage(error)}\`
+    });
+    throw error;
+  });
+
+  diagnostics(): readonly AnQstBridgeDiagnostic[] {
+    return this._diagnostics();
+  }
+
+  state(): AnQstBridgeState {
+    return this._state();
+  }
+
+  subscribeDiagnostics(listener: (diagnostic: AnQstBridgeDiagnostic) => void): () => void {
+    this.diagnosticListeners.add(listener);
+    return () => this.diagnosticListeners.delete(listener);
+  }
 
   async ready(): Promise<void> {
     return this.startup;
   }
 
+  reportFrontendDiagnostic(diagnostic: Omit<AnQstBridgeDiagnostic, "timestamp" | "source">): void {
+    this.pushDiagnostic({
+      ...diagnostic,
+      source: "frontend",
+      transport: diagnostic.transport ?? this.adapter?.transport,
+      timestamp: new Date().toISOString()
+    });
+  }
+
   async call<T>(service: string, member: string, args: unknown[]): Promise<T> {
     const adapter = await this.requireAdapter();
     return adapter.call<T>(service, member, args);
   }
 
   emit(service: string, member: string, args: unknown[]): void {
-    if (this.adapter !== null) {
-      this.adapter.emit(service, member, args);
-      return;
-    }
-    this.ready()
-      .then(() => this.requireAdapterSync().emit(service, member, args))
-      .catch((error) => console.error(error));
+    this.publishNonCall("Emitter", service, member, (adapter) => adapter.emit(service, member, args));
   }
 
   setInput(service: string, member: string, value: unknown): void {
-    if (this.adapter !== null) {
-      this.adapter.setInput(service, member, value);
-      return;
-    }
-    this.ready()
-      .then(() => this.requireAdapterSync().setInput(service, member, value))
-      .catch((error) => console.error(error));
+    this.publishNonCall("Input", service, member, (adapter) => adapter.setInput(service, member, value));
   }
 
   registerSlot(service: string, member: string, handler: SlotHandler): void {
     const key = this.key(service, member);
     this.slotHandlers.set(key, handler);
     if (this.adapter !== null) {
-      this.adapter.registerSlot(service, member);
+      try {
+        this.adapter.registerSlot(service, member);
+      } catch (error) {
+        this.reportFrontendDiagnostic({
+          code: "BridgePublishError",
+          severity: "error",
+          category: "bridge",
+          recoverable: true,
+          message: \`Failed to register Slot \${service}.\${member}: \${errorMessage(error)}\`,
+          service,
+          member,
+          context: { interaction: "Slot" }
+        });
+      }
       return;
     }
     this.ready()
-      .then(() => this.requireAdapterSync().registerSlot(service, member))
-      .catch((error) => console.error(error));
+      .then(() => {
+        try {
+          this.requireAdapterSync().registerSlot(service, member);
+        } catch (error) {
+          this.reportFrontendDiagnostic({
+            code: "BridgePublishError",
+            severity: "error",
+            category: "bridge",
+            recoverable: true,
+            message: \`Failed to register Slot \${service}.\${member}: \${errorMessage(error)}\`,
+            service,
+            member,
+            context: { interaction: "Slot" }
+          });
+        }
+      })
+      .catch((error) => {
+        this.reportFrontendDiagnostic({
+          code: "BridgePublishError",
+          severity: "error",
+          category: "bridge",
+          recoverable: true,
+          message: \`Failed to register Slot \${service}.\${member}: \${errorMessage(error)}\`,
+          service,
+          member,
+          context: { interaction: "Slot" }
+        });
+      });
   }
 
   onOutput(service: string, member: string, handler: OutputHandler): void {
@@ -1917,6 +2870,73 @@ class AnQstBridgeRuntime {
     return this.requireAdapterSync();
   }
 
+  private pushDiagnostic(diagnostic: AnQstBridgeDiagnostic): void {
+    const previous = this._diagnostics();
+    const trimmed = previous.length >= AnQstBridgeRuntime.maxDiagnostics
+      ? previous.slice(previous.length - (AnQstBridgeRuntime.maxDiagnostics - 1))
+      : previous;
+    const next = [...trimmed, diagnostic];
+    this._diagnostics.set(next);
+    for (const listener of this.diagnosticListeners) {
+      listener(diagnostic);
+    }
+  }
+
+  private publishNonCall(
+    interaction: "Emitter" | "Input",
+    service: string,
+    member: string,
+    publish: (adapter: BridgeAdapter) => void
+  ): void {
+    if (this.adapter !== null) {
+      try {
+        publish(this.adapter);
+      } catch (error) {
+        this.reportFrontendDiagnostic({
+          code: "BridgePublishError",
+          severity: "error",
+          category: "bridge",
+          recoverable: true,
+          message: \`Failed to publish \${interaction} \${service}.\${member}: \${errorMessage(error)}\`,
+          service,
+          member,
+          context: { interaction }
+        });
+      }
+      return;
+    }
+
+    this.ready()
+      .then(() => {
+        try {
+          publish(this.requireAdapterSync());
+        } catch (error) {
+          this.reportFrontendDiagnostic({
+            code: "BridgePublishError",
+            severity: "error",
+            category: "bridge",
+            recoverable: true,
+            message: \`Failed to publish \${interaction} \${service}.\${member}: \${errorMessage(error)}\`,
+            service,
+            member,
+            context: { interaction }
+          });
+        }
+      })
+      .catch((error) => {
+        this.reportFrontendDiagnostic({
+          code: "BridgePublishError",
+          severity: "error",
+          category: "bridge",
+          recoverable: true,
+          message: \`Failed to publish \${interaction} \${service}.\${member}: \${errorMessage(error)}\`,
+          service,
+          member,
+          context: { interaction }
+        });
+      });
+  }
+
   private async init(): Promise<void> {
     const anyWindow = window as unknown as { qt?: { webChannelTransport?: unknown }; QWebChannel?: QWebChannelCtor };
     if (typeof anyWindow.QWebChannel === "function" && anyWindow.qt?.webChannelTransport !== undefined) {
@@ -1925,44 +2945,98 @@ class AnQstBridgeRuntime {
       this.adapter = await WebSocketBridgeAdapter.create();
     }
 
-    this.adapter.onOutput((service, member, value) => {
+    const adapter = this.adapter;
+    adapter.onHostDiagnostic((payload) => {
+      this.pushDiagnostic({
+        ...normalizeHostDiagnostic(payload, adapter.transport),
+        timestamp: new Date().toISOString()
+      });
+    });
+    adapter.onDisconnected(() => {
+      this._state.set("disconnected");
+      this.reportFrontendDiagnostic({
+        code: "BridgeDisconnectedError",
+        severity: "error",
+        category: "bridge",
+        recoverable: true,
+        message: "Bridge disconnected.",
+        transport: adapter.transport
+      });
+    });
+
+    adapter.onOutput((service, member, value) => {
       const key = this.key(service, member);
       for (const outputHandler of this.outputHandlers.get(key) ?? []) {
         outputHandler(value);
       }
     });
-    this.adapter.onSlotInvocation(async (requestId, service, member, args) => {
+    adapter.onSlotInvocation(async (requestId, service, member, args) => {
       const key = this.key(service, member);
       const handler = this.slotHandlers.get(key);
       if (handler === undefined) {
-        this.adapter!.resolveSlot(requestId, false, undefined, "No slot handler registered.");
+        this.reportFrontendDiagnostic({
+          code: "HandlerNotRegisteredError",
+          severity: "error",
+          category: "bridge",
+          recoverable: true,
+          message: \`No slot handler registered for \${service}.\${member}.\`,
+          service,
+          member,
+          requestId,
+          context: { interaction: "Slot" }
+        });
+        adapter.resolveSlot(requestId, false, undefined, "No slot handler registered.");
         return;
       }
       try {
         const result = await Promise.resolve(handler(...args));
         if (result instanceof Error) {
-          this.adapter!.resolveSlot(requestId, false, undefined, result.message);
+          this.reportFrontendDiagnostic({
+            code: "SlotRequestFailed",
+            severity: "error",
+            category: "bridge",
+            recoverable: true,
+            message: result.message.length > 0
+              ? result.message
+              : \`Slot \${service}.\${member} returned an Error.\`,
+            service,
+            member,
+            requestId,
+            context: { interaction: "Slot" }
+          });
+          adapter.resolveSlot(requestId, false, undefined, result.message);
           return;
         }
-        this.adapter!.resolveSlot(requestId, true, result, "");
+        adapter.resolveSlot(requestId, true, result, "");
       } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        this.adapter!.resolveSlot(requestId, false, undefined, message);
+        const message = errorMessage(error);
+        this.reportFrontendDiagnostic({
+          code: "SlotHandlerError",
+          severity: "error",
+          category: "bridge",
+          recoverable: true,
+          message: \`Slot handler \${service}.\${member} threw: \${message}\`,
+          service,
+          member,
+          requestId,
+          context: { interaction: "Slot" }
+        });
+        adapter.resolveSlot(requestId, false, undefined, message);
       }
     });
-    this.adapter.onDrop((service, member, payload, x, y) => {
+    adapter.onDrop((service, member, payload, x, y) => {
       const key = this.key(service, member);
       for (const handler of this.dropHandlers.get(key) ?? []) {
         handler(payload, x, y);
       }
     });
-    this.adapter.onHover((service, member, payload, x, y) => {
+    adapter.onHover((service, member, payload, x, y) => {
       const key = this.key(service, member);
       for (const handler of this.hoverHandlers.get(key) ?? []) {
         handler(payload, x, y);
       }
     });
-    this.adapter.onHoverLeft((service, member) => {
+    adapter.onHoverLeft((service, member) => {
       const key = this.key(service, member);
       for (const handler of this.hoverLeftHandlers.get(key) ?? []) {
         handler();
@@ -1971,9 +3045,10 @@ class AnQstBridgeRuntime {
     for (const key of this.slotHandlers.keys()) {
       const parts = key.split("::");
       if (parts.length === 2) {
-        this.adapter.registerSlot(parts[0], parts[1]);
+        adapter.registerSlot(parts[0], parts[1]);
       }
     }
+    this._state.set("ready");
   }
 
   private key(service: string, member: string): string {
@@ -1981,6 +3056,23 @@ class AnQstBridgeRuntime {
   }
 
 }
+
+@Injectable({ providedIn: "root" })
+export class AnQstBridgeDiagnostics {
+  private readonly _bridge = inject(AnQstBridgeRuntime);
+
+  diagnostics(): readonly AnQstBridgeDiagnostic[] {
+    return this._bridge.diagnostics();
+  }
+
+  state(): AnQstBridgeState {
+    return this._bridge.state();
+  }
+
+  subscribe(listener: (diagnostic: AnQstBridgeDiagnostic) => void): () => void {
+    return this._bridge.subscribeDiagnostics(listener);
+  }
+}
 ${serviceClasses}
 `;
 }
@@ -1993,10 +3085,38 @@ function renderTsTypes(spec) {
 function renderTypeServicesDts(spec) {
     const externalTypeImports = renderRequiredTypeImports(spec, `frontend/${(0, layout_1.generatedFrontendDirName)(spec.widgetName)}/types/services.d.ts`).trim();
     const localTypeImports = renderLocalTypeImports(spec).trim();
+    const bridgeDiagnosticsDecl = `export type AnQstBridgeSeverity = "info" | "warn" | "error" | "fatal";
+
+export type AnQstBridgeSource = "frontend" | "host";
+
+export type AnQstBridgeTransport = "qt-webchannel" | "dev-websocket";
+
+export type AnQstBridgeState = "starting" | "ready" | "failed" | "disconnected";
+
+export interface AnQstBridgeDiagnostic {
+  code: string;
+  severity: AnQstBridgeSeverity;
+  category: string;
+  recoverable: boolean;
+  message: string;
+  timestamp: string;
+  source: AnQstBridgeSource;
+  transport?: AnQstBridgeTransport;
+  service?: string;
+  member?: string;
+  requestId?: string;
+  context?: Record<string, unknown>;
+}
+
+export declare class AnQstBridgeDiagnostics {
+  diagnostics(): readonly AnQstBridgeDiagnostic[];
+  state(): AnQstBridgeState;
+  subscribe(listener: (diagnostic: AnQstBridgeDiagnostic) => void): () => void;
+}`;
     const serviceDecls = spec.services
         .map((s) => renderTsServiceDts(spec, s.name))
         .join("\n\n");
-    const sections = [externalTypeImports, localTypeImports, serviceDecls.trim()].filter((s) => s.length > 0);
+    const sections = [externalTypeImports, localTypeImports, bridgeDiagnosticsDecl, serviceDecls.trim()].filter((s) => s.length > 0);
     return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
 }
 function renderTypeTypesDts(spec) {
@@ -2071,7 +3191,7 @@ function renderNodeExpressWsTypes(spec) {
     const sections = [typeImports, typeDecls].filter((s) => s.length > 0);
     return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
 }
-function renderNodeExpressWsIndex(spec) {
+function renderNodeExpressWsIndex(spec, codecCatalog) {
     const typeImports = renderRequiredTypeImports(spec, `backend/node/express/${generatedNodeExpressWsDirName(spec.widgetName)}/index.ts`);
     const typeDecls = renderTypeDeclarations(spec, true);
     const handlerBridgeTypeName = `${spec.widgetName}HandlerBridge`;
@@ -2103,8 +3223,13 @@ function renderNodeExpressWsIndex(spec) {
         .map((member) => {
         const ret = mapTypeTextToTs(member.payloadTypeText ?? "void");
         const args = nodeParamArgs(member);
+        const paramSites = member.parameters.map((p) => (0, boundary_codecs_1.getBoundaryParameterSite)(codecCatalog, service.name, member.name, p.name));
+        const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(codecCatalog, service.name, member.name);
+        const encodedArgs = member.parameters.length > 0
+            ? `[${member.parameters.map((p, index) => `${paramSites[index] ? `encode${paramSites[index].codecId}(${p.name})` : p.name}`).join(", ")}]`
+            : "[]";
         return `  ${service.name}_${member.name}(${args}${args ? ", " : ""}timeoutMs = this.defaultSlotTimeoutMs): Promise<${ret}> {
-    return this.invokeSlot("${service.name}", "${member.name}", ${nodeParamValues(member)}, timeoutMs) as Promise<${ret}>;
+    return this.invokeSlot("${service.name}", "${member.name}", ${encodedArgs}, timeoutMs).then((value) => ${payloadSite ? `decode${payloadSite.codecId}(value)` : `value as ${ret}`});
   }`;
     }))
         .join("\n");
@@ -2113,8 +3238,9 @@ function renderNodeExpressWsIndex(spec) {
         .filter((member) => member.kind === "Output" && member.payloadTypeText)
         .map((member) => {
         const typeText = mapTypeTextToTs(member.payloadTypeText);
+        const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(codecCatalog, service.name, member.name);
         return `  set${service.name}_${nodeCap(member.name)}(value: ${typeText}): void {
-    this.setOutputValue("${service.name}", "${member.name}", value);
+    this.setOutputValue("${service.name}", "${member.name}", ${payloadSite ? `encode${payloadSite.codecId}(value)` : "value"});
   }`;
     }))
         .join("\n");
@@ -2167,8 +3293,9 @@ function renderNodeExpressWsIndex(spec) {
             .filter((member) => (member.kind === "Input" || member.kind === "Output") && member.payloadTypeText)
             .map((member) => {
             const typeText = mapTypeTextToTs(member.payloadTypeText);
+            const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(codecCatalog, service.name, member.name);
             if (member.kind === "Input") {
-                return `            ${member.name}: {\n              get: () => session.readInput("${service.name}", "${member.name}") as Promise<${typeText}>,\n              on: (handler: (value: ${typeText}) => void) => session.onInput("${service.name}", "${member.name}", handler as (value: unknown) => void)\n            },`;
+                return `            ${member.name}: {\n              get: () => session.readInput("${service.name}", "${member.name}").then((value) => ${payloadSite ? `decode${payloadSite.codecId}(value)` : `value as ${typeText}`}),\n              on: (handler: (value: ${typeText}) => void) => session.onInput("${service.name}", "${member.name}", (value) => handler(${payloadSite ? `decode${payloadSite.codecId}(value)` : `value as ${typeText}`}))\n            },`;
             }
             return `            ${member.name}: {\n              set: (value: ${typeText}) => session.set${service.name}_${nodeCap(member.name)}(value)\n            },`;
         })
@@ -2180,6 +3307,11 @@ function renderNodeExpressWsIndex(spec) {
         .flatMap((service) => service.members
         .filter((member) => member.kind === "Call" && member.payloadTypeText)
         .map((member) => {
+        const paramSites = member.parameters.map((p) => (0, boundary_codecs_1.getBoundaryParameterSite)(codecCatalog, service.name, member.name, p.name));
+        const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(codecCatalog, service.name, member.name);
+        const decodedArgs = member.parameters.length > 0
+            ? member.parameters.map((p, index) => `${paramSites[index] ? `decode${paramSites[index].codecId}(args[${index}])` : `args[${index}] as ${mapTypeTextToTs(p.typeText)}`}`).join(", ")
+            : "";
         return `    if (service === "${service.name}" && member === "${member.name}") {
       const handler = implementation.${service.name}.${member.name};
       if (typeof handler !== "function") {
@@ -2202,8 +3334,8 @@ function renderNodeExpressWsIndex(spec) {
         });
         throw err;
       }
-      Promise.resolve(handler(buildHandlerBridge(session), ...(args as ${nodeParamTuple(member)})))
-        .then((result) => sendJson(session.socket, { type: "callResult", requestId, result }))
+      Promise.resolve(handler(buildHandlerBridge(session)${decodedArgs ? `, ${decodedArgs}` : ""}))
+        .then((result) => sendJson(session.socket, { type: "callResult", requestId, result: ${payloadSite ? `encode${payloadSite.codecId}(result)` : "result"} }))
         .catch((error) => {
           const message = error instanceof Error ? error.message : String(error);
           emitDiagnostic({
@@ -2231,6 +3363,13 @@ function renderNodeExpressWsIndex(spec) {
         .flatMap((service) => service.members
         .filter((member) => member.kind === "Emitter")
         .map((member) => {
+        const paramSites = member.parameters.map((p) => (0, boundary_codecs_1.getBoundaryParameterSite)(codecCatalog, service.name, member.name, p.name));
+        const decodedArgs = member.parameters.length > 0
+            ? member.parameters.map((p, index) => `${paramSites[index] ? `decode${paramSites[index].codecId}(args[${index}])` : `args[${index}] as ${mapTypeTextToTs(p.typeText)}`}`).join(", ")
+            : "";
+        const decodedSignalArgs = member.parameters.length > 0
+            ? `[${member.parameters.map((p, index) => `${paramSites[index] ? `decode${paramSites[index].codecId}(args[${index}])` : `args[${index}] as ${mapTypeTextToTs(p.typeText)}`}`).join(", ")}]`
+            : "[]";
         return `    if (service === "${service.name}" && member === "${member.name}") {
       const handler = implementation.${service.name}.${member.name};
       if (typeof handler !== "function") {
@@ -2247,7 +3386,8 @@ function renderNodeExpressWsIndex(spec) {
         });
         throw err;
       }
-      void Promise.resolve(handler(buildHandlerBridge(session), ...(args as ${nodeParamTuple(member)}))).catch((error) => {
+      session.emitSignal(service, member, ${decodedSignalArgs});
+      void Promise.resolve(handler(buildHandlerBridge(session)${decodedArgs ? `, ${decodedArgs}` : ""})).catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
         emitDiagnostic({
           code: "EmitterHandlerError",
@@ -2268,6 +3408,7 @@ function renderNodeExpressWsIndex(spec) {
         .flatMap((service) => service.members
         .filter((member) => member.kind === "Input" && member.payloadTypeText)
         .map((member) => {
+        const payloadSite = (0, boundary_codecs_1.getBoundaryPayloadSite)(codecCatalog, service.name, member.name);
         return `    if (service === "${service.name}" && member === "${member.name}") {
       const handler = implementation.${service.name}.${member.name};
       if (typeof handler !== "function") {
@@ -2284,7 +3425,9 @@ function renderNodeExpressWsIndex(spec) {
         });
         throw err;
       }
-      void Promise.resolve(handler(buildHandlerBridge(session), value as ${mapTypeTextToTs(member.payloadTypeText)})).catch((error) => {
+      const decodedValue = ${payloadSite ? `decode${payloadSite.codecId}(value)` : `value as ${mapTypeTextToTs(member.payloadTypeText)}`};
+      session.setInputState(service, member, decodedValue);
+      void Promise.resolve(handler(buildHandlerBridge(session), decodedValue)).catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
         emitDiagnostic({
           code: "InputHandlerError",
@@ -2306,6 +3449,9 @@ import type { WebSocket, WebSocketServer } from "ws";
 ${typeImports}
 ${typeDecls}
 
+// Boundary codec plan helpers
+${(0, boundary_codecs_1.renderTsBoundaryCodecHelpers)(codecCatalog)}
+
 ${handlerInterfaces}
 
 export interface ${spec.widgetName}NodeImplementation {
@@ -2672,7 +3818,6 @@ ${callDispatch}
       const service = String(message.service ?? "");
       const member = String(message.member ?? "");
       const args = Array.isArray(message.args) ? (message.args as unknown[]) : [];
-      session.emitSignal(service, member, args);
 ${emitterDispatch}
       const err = new Error(\`No Emitter mapping found for \${service}.\${member}\`);
       emitDiagnostic({
@@ -2691,7 +3836,6 @@ ${emitterDispatch}
       const service = String(message.service ?? "");
       const member = String(message.member ?? "");
       const value = message.value;
-      session.setInputState(service, member, value);
 ${inputDispatch}
       const err = new Error(\`No Input mapping found for \${service}.\${member}\`);
       emitDiagnostic({
@@ -2768,7 +3912,23 @@ function renderTypeRootIndexDts(spec) {
     const typeDecls = renderTypeTypesDts(spec).trim();
     const serviceDecls = renderTypeServicesDts(spec).trim();
     const sections = [indexDecls, typeDecls, serviceDecls].filter((s) => s.length > 0);
-    return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
+    if (sections.length === 0)
+        return "";
+    const dedupedLines = [];
+    const seenImportLines = new Set();
+    for (const line of sections.join("\n\n").split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("import type ")) {
+            dedupedLines.push(line);
+            continue;
+        }
+        if (seenImportLines.has(trimmed))
+            continue;
+        seenImportLines.add(trimmed);
+        dedupedLines.push(line);
+    }
+    const deduped = dedupedLines.join("\n").replace(/\n{3,}/g, "\n\n");
+    return `${deduped}\n`;
 }
 function generatedCppLibraryDirName(widgetName) {
     return (0, layout_1.generatedQtWidgetDirName)(widgetName);
@@ -2781,10 +3941,11 @@ function generateOutputs(spec, options = { emitQWidget: true, emitAngularService
     const cppDir = `backend/cpp/qt/${generatedCppLibraryDirName(spec.widgetName)}`;
     const nodeDir = `backend/node/express/${generatedNodeExpressWsDirName(spec.widgetName)}`;
     const outputs = {};
+    const codecCatalog = (0, boundary_codecs_1.buildBoundaryCodecCatalog)(spec);
     if (options.emitAngularService) {
         outputs[`${frontendDir}/package.json`] = renderNpmPackage(spec);
         outputs[`${frontendDir}/index.ts`] = renderTsIndex();
-        outputs[`${frontendDir}/services.ts`] = renderTsServices(spec);
+        outputs[`${frontendDir}/services.ts`] = renderTsServices(spec, codecCatalog);
         outputs[`${frontendDir}/types.ts`] = renderTsTypes(spec);
         outputs[`${frontendDir}/index.js`] = renderJsIndex();
         outputs[`${frontendDir}/services.js`] = renderJsServices();
@@ -2798,13 +3959,13 @@ function generateOutputs(spec, options = { emitQWidget: true, emitAngularService
         outputs[`${cppDir}/CMakeLists.txt`] = renderCMake(spec);
         outputs[`${cppDir}/${spec.widgetName}.qrc`] = renderEmbeddedQrc(spec.widgetName, []);
         outputs[`${cppDir}/include/${spec.widgetName}.h`] = renderWidgetUmbrellaHeader(spec);
-        outputs[`${cppDir}/include/${spec.widgetName}Widget.h`] = renderWidgetHeader(spec, cppTypes);
+        outputs[`${cppDir}/include/${spec.widgetName}Widget.h`] = renderWidgetHeader(spec, cppTypes, codecCatalog);
         outputs[`${cppDir}/include/${spec.widgetName}Types.h`] = renderTypesHeader(spec, cppTypes);
-        outputs[`${cppDir}/${spec.widgetName}.cpp`] = renderCppStub(spec, cppTypes);
+        outputs[`${cppDir}/${spec.widgetName}.cpp`] = renderCppStub(spec, cppTypes, codecCatalog);
     }
     if (options.emitNodeExpressWs) {
         outputs[`${nodeDir}/package.json`] = renderNodeExpressWsPackage(spec);
-        outputs[`${nodeDir}/index.ts`] = renderNodeExpressWsIndex(spec);
+        outputs[`${nodeDir}/index.ts`] = renderNodeExpressWsIndex(spec, codecCatalog);
         outputs[`${nodeDir}/types/index.d.ts`] = renderNodeExpressWsTypes(spec);
     }
     return outputs;
@@ -2985,13 +4146,15 @@ function renderQtIntegrationCMake(widgetName) {
     const generatedRootVar = "ANQST_GENERATED_WIDGET_DIR";
     const generatedIncludeVar = "ANQST_GENERATED_INCLUDE_DIR";
     const projectRootVar = "ANQST_PROJECT_ROOT";
+    const requiredFilesVar = "ANQST_REQUIRED_GENERATED_FILES";
+    const widgetBinaryDirVar = "ANQST_GENERATED_WIDGET_BINARY_DIR";
     const widgetTarget = `${widgetName}Widget`;
-    const autogenTarget = `${widgetTarget}_anqst_codegen`;
     return `cmake_minimum_required(VERSION 3.21)
 
 set(${projectRootVar} "\${CMAKE_CURRENT_LIST_DIR}/../../../../..")
 set(${generatedRootVar} "\${CMAKE_CURRENT_LIST_DIR}/../qt/${generatedCppLibraryDirName(widgetName)}")
 set(${generatedIncludeVar} "\${${generatedRootVar}}/include")
+set(${widgetBinaryDirVar} "\${CMAKE_CURRENT_BINARY_DIR}/${generatedCppLibraryDirName(widgetName)}")
 
 if(TARGET ${widgetTarget})
     return()
@@ -3001,66 +4164,27 @@ if(NOT TARGET anqstwebhostbase)
     message(FATAL_ERROR "Target 'anqstwebhostbase' must exist before including generated AnQst CMake for ${widgetName}.")
 endif()
 
-find_package(Qt5 REQUIRED COMPONENTS Core Widgets)
-set(CMAKE_AUTOMOC ON)
-set(CMAKE_AUTOUIC ON)
-set(CMAKE_AUTORCC ON)
-
-find_program(ANQST_NPM_EXECUTABLE npm REQUIRED)
-find_program(ANQST_NPX_EXECUTABLE npx REQUIRED)
-
-add_custom_command(
-    OUTPUT
-        "\${${generatedRootVar}}/CMakeLists.txt"
-        "\${${generatedRootVar}}/${widgetName}.qrc"
-        "\${${generatedRootVar}}/${widgetName}.cpp"
-        "\${${generatedIncludeVar}}/${widgetName}.h"
-        "\${${generatedIncludeVar}}/${widgetName}Widget.h"
-        "\${${generatedIncludeVar}}/${widgetName}Types.h"
-        "\${${generatedRootVar}}/webapp/index.html"
-    COMMAND "\${ANQST_NPM_EXECUTABLE}" install
-    COMMAND "\${ANQST_NPX_EXECUTABLE}" anqst build
-    WORKING_DIRECTORY "\${${projectRootVar}}"
-    COMMENT "Generating AnQst widget library (${widgetTarget}) from Angular project"
-    VERBATIM
-)
-
-add_custom_target(${autogenTarget}
-    DEPENDS
-        "\${${generatedRootVar}}/CMakeLists.txt"
-        "\${${generatedRootVar}}/${widgetName}.qrc"
-        "\${${generatedRootVar}}/${widgetName}.cpp"
-        "\${${generatedIncludeVar}}/${widgetName}.h"
-        "\${${generatedIncludeVar}}/${widgetName}Widget.h"
-        "\${${generatedIncludeVar}}/${widgetName}Types.h"
-        "\${${generatedRootVar}}/webapp/index.html"
-)
-
-set_source_files_properties(
+set(${requiredFilesVar}
+    "\${${generatedRootVar}}/CMakeLists.txt"
     "\${${generatedRootVar}}/${widgetName}.qrc"
     "\${${generatedRootVar}}/${widgetName}.cpp"
     "\${${generatedIncludeVar}}/${widgetName}.h"
     "\${${generatedIncludeVar}}/${widgetName}Widget.h"
     "\${${generatedIncludeVar}}/${widgetName}Types.h"
-    PROPERTIES GENERATED TRUE
+    "\${${generatedRootVar}}/webapp/index.html"
 )
 
-add_library(${widgetTarget}
-    "\${${generatedRootVar}}/${widgetName}.qrc"
-    "\${${generatedRootVar}}/${widgetName}.cpp"
-    "\${${generatedIncludeVar}}/${widgetName}.h"
-    "\${${generatedIncludeVar}}/${widgetName}Widget.h"
-    "\${${generatedIncludeVar}}/${widgetName}Types.h"
-)
-add_dependencies(${widgetTarget} ${autogenTarget})
-target_include_directories(${widgetTarget}
-    PUBLIC
-        "\${${generatedIncludeVar}}"
-)
-target_link_libraries(${widgetTarget}
-    PUBLIC
-        anqstwebhostbase
-)
+foreach(required_file IN LISTS ${requiredFilesVar})
+    if(NOT EXISTS "\${required_file}")
+        message(FATAL_ERROR
+            "Generated AnQst widget tree is incomplete for ${widgetName}. "
+            "Missing file: \${required_file}. "
+            "Run 'npx anqst build' in '\${${projectRootVar}}' first."
+        )
+    endif()
+endforeach()
+
+add_subdirectory("\${${generatedRootVar}}" "\${${widgetBinaryDirVar}}")
 `;
 }
 function installQtIntegrationCMake(cwd, widgetName) {