@dusted/anqst 0.1.0

package/dist/src/emit.js

@@ -0,0 +1,2500 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOutputs = generateOutputs;
+exports.writeGeneratedOutputs = writeGeneratedOutputs;
+exports.installTypeScriptOutputs = installTypeScriptOutputs;
+exports.installEmbeddedWebBundle = installEmbeddedWebBundle;
+exports.installQtIntegrationCMake = installQtIntegrationCMake;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+function stripAnQstType(typeText) {
+    return typeText
+        .replace(/\bAnQst\.Type\.stringArray\b/g, "string[]")
+        .replace(/\bAnQst\.Type\.string\b/g, "string")
+        .replace(/\bAnQst\.Type\.number\b/g, "number")
+        .replace(/\bAnQst\.Type\.qint64\b/g, "bigint")
+        .replace(/\bAnQst\.Type\.quint64\b/g, "bigint")
+        .replace(/\bAnQst\.Type\.qint32\b/g, "number")
+        .replace(/\bAnQst\.Type\.quint32\b/g, "number")
+        .replace(/\bAnQst\.Type\.object\b/g, "object")
+        .replace(/\bAnQst\.Type\.json\b/g, "object");
+}
+function splitGeneric(typeText) {
+    const m = typeText.match(/^([A-Za-z0-9_.]+)<(.+)>$/);
+    if (!m)
+        return null;
+    return { name: m[1], arg: m[2].trim() };
+}
+function mapTsTypeToCpp(typeText) {
+    const raw = typeText.trim();
+    if (/\bAnQst\.Type\.qint64\b/.test(raw))
+        return "qint64";
+    if (/\bAnQst\.Type\.quint64\b/.test(raw))
+        return "quint64";
+    if (/\bAnQst\.Type\.qint32\b/.test(raw))
+        return "qint32";
+    if (/\bAnQst\.Type\.quint32\b/.test(raw))
+        return "quint32";
+    if (/\bAnQst\.Type\.qint16\b/.test(raw))
+        return "qint16";
+    if (/\bAnQst\.Type\.quint16\b/.test(raw))
+        return "quint16";
+    if (/\bAnQst\.Type\.qint8\b/.test(raw))
+        return "qint8";
+    if (/\bAnQst\.Type\.quint8\b/.test(raw))
+        return "quint8";
+    if (/\bAnQst\.Type\.stringArray\b/.test(raw))
+        return "QStringList";
+    if (/\bAnQst\.Type\.string\b/.test(raw))
+        return "QString";
+    if (/\bAnQst\.Type\.json\b/.test(raw) || /\bAnQst\.Type\.object\b/.test(raw))
+        return "QVariantMap";
+    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")
+            return "int8_t";
+        if (narrowed === "uint8")
+            return "uint8_t";
+        if (narrowed === "int16")
+            return "int16_t";
+        if (narrowed === "uint16")
+            return "uint16_t";
+        if (narrowed === "int32")
+            return "int32_t";
+        if (narrowed === "uint32")
+            return "uint32_t";
+    }
+    const t = stripAnQstType(raw);
+    if (t === "string")
+        return "QString";
+    if (t === "number")
+        return "double";
+    if (t === "boolean")
+        return "bool";
+    if (t === "bigint")
+        return "qint64";
+    if (t === "void")
+        return "void";
+    if (t === "object")
+        return "QVariantMap";
+    if (t.endsWith("[]")) {
+        return `QList<${mapTsTypeToCpp(t.slice(0, -2))}>`;
+    }
+    const g = splitGeneric(t);
+    if (g && g.name === "Array")
+        return `QList<${mapTsTypeToCpp(g.arg)}>`;
+    if (g && g.name === "ReadonlyArray")
+        return `QList<${mapTsTypeToCpp(g.arg)}>`;
+    if (g && g.name === "Record")
+        return "QVariantMap";
+    if (g && g.name === "Partial")
+        return mapTsTypeToCpp(g.arg);
+    if (g && g.name === "Promise")
+        return mapTsTypeToCpp(g.arg);
+    if (t.includes("|"))
+        return "QString";
+    return t;
+}
+function toCppArgs(member) {
+    return member.parameters.map((p) => `${mapTsTypeToCpp(p.typeText)} ${p.name}`).join(", ");
+}
+function callbackName(memberName) {
+    return `${memberName.charAt(0).toUpperCase()}${memberName.slice(1)}Callback`;
+}
+function pascalCase(value) {
+    return value.length === 0 ? value : `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+function variantToCppExpression(cppType, expr) {
+    if (cppType === "QString")
+        return `${expr}.toString()`;
+    if (cppType === "QStringList")
+        return `${expr}.toStringList()`;
+    if (cppType === "QVariantMap")
+        return `${expr}.toMap()`;
+    if (cppType === "double")
+        return `${expr}.toDouble()`;
+    if (cppType === "bool")
+        return `${expr}.toBool()`;
+    if (cppType === "qint64")
+        return `${expr}.toLongLong()`;
+    if (cppType === "quint64")
+        return `${expr}.toULongLong()`;
+    if (cppType === "qint32" || cppType === "quint32")
+        return `${expr}.toInt()`;
+    if (cppType === "qint16" || cppType === "quint16")
+        return `static_cast<${cppType}>(${expr}.toInt())`;
+    if (cppType === "qint8" || cppType === "quint8")
+        return `static_cast<${cppType}>(${expr}.toInt())`;
+    if (cppType === "int8_t" || cppType === "uint8_t" || cppType === "int16_t" || cppType === "uint16_t" || cppType === "int32_t" || cppType === "uint32_t") {
+        return `static_cast<${cppType}>(${expr}.toInt())`;
+    }
+    return `${expr}.value<${cppType}>()`;
+}
+function cppToVariantExpression(cppType, expr) {
+    if (cppType === "QString" ||
+        cppType === "QStringList" ||
+        cppType === "QVariantMap" ||
+        cppType === "double" ||
+        cppType === "bool" ||
+        cppType === "qint64" ||
+        cppType === "quint64" ||
+        cppType === "qint32" ||
+        cppType === "quint32" ||
+        cppType === "qint16" ||
+        cppType === "quint16" ||
+        cppType === "qint8" ||
+        cppType === "quint8" ||
+        cppType === "int8_t" ||
+        cppType === "uint8_t" ||
+        cppType === "int16_t" ||
+        cppType === "uint16_t" ||
+        cppType === "int32_t" ||
+        cppType === "uint32_t") {
+        return `QVariant::fromValue(${expr})`;
+    }
+    return `QVariant::fromValue(${expr})`;
+}
+function collectStructDecls(spec) {
+    const out = new Map();
+    for (const d of spec.namespaceTypeDecls)
+        out.set(d.name, d);
+    for (const d of spec.importedTypeDecls.values())
+        out.set(d.name, d);
+    return [...out.values()];
+}
+function mapTypeTextToTs(typeText) {
+    return stripAnQstType(typeText.trim());
+}
+function parseTypeNodeFromText(typeText) {
+    const source = typescript_1.default.createSourceFile("__inline__.ts", `type __X = ${typeText};`, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
+    const stmt = source.statements.find(typescript_1.default.isTypeAliasDeclaration);
+    if (!stmt) {
+        throw new Error(`Unable to parse type text: ${typeText}`);
+    }
+    return stmt.type;
+}
+function qNameText(name) {
+    if (typescript_1.default.isIdentifier(name))
+        return name.text;
+    return `${qNameText(name.left)}.${name.right.text}`;
+}
+function typeRefs(typeNode) {
+    const refs = new Set();
+    const visit = (node) => {
+        if (typescript_1.default.isTypeReferenceNode(node))
+            refs.add(qNameText(node.typeName));
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(typeNode);
+    return [...refs];
+}
+function isBuiltinOrLiteral(ref) {
+    return [
+        "string",
+        "number",
+        "boolean",
+        "void",
+        "object",
+        "bigint",
+        "BigInt",
+        "Array",
+        "ReadonlyArray",
+        "Record",
+        "Partial",
+        "Readonly",
+        "Date"
+    ].includes(ref);
+}
+function collectReachableNamespaceDecls(spec) {
+    const localByName = new Map(spec.namespaceTypeDecls.map((decl) => [decl.name, decl]));
+    const queue = [...spec.namespaceTypeDecls.map((decl) => decl.name)];
+    const seen = new Set();
+    const ordered = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (seen.has(current))
+            continue;
+        seen.add(current);
+        const decl = localByName.get(current);
+        if (!decl)
+            continue;
+        ordered.push(decl);
+        for (const ref of decl.referencedTypeNames) {
+            if (localByName.has(ref) && !seen.has(ref)) {
+                queue.push(ref);
+            }
+        }
+    }
+    return ordered;
+}
+function collectRequiredImportedSymbols(spec) {
+    const required = new Set();
+    const localTypeNames = new Set(spec.namespaceTypeDecls.map((d) => d.name));
+    const collectRef = (ref) => {
+        if (isBuiltinOrLiteral(ref))
+            return;
+        if (ref.startsWith("AnQst."))
+            return;
+        if (localTypeNames.has(ref))
+            return;
+        required.add(ref.split(".")[0]);
+    };
+    for (const decl of collectReachableNamespaceDecls(spec)) {
+        for (const ref of decl.referencedTypeNames)
+            collectRef(ref);
+    }
+    for (const service of spec.services) {
+        for (const member of service.members) {
+            const texts = [...member.parameters.map((p) => p.typeText)];
+            if (member.payloadTypeText)
+                texts.push(member.payloadTypeText);
+            for (const typeText of texts) {
+                for (const ref of typeRefs(parseTypeNodeFromText(typeText))) {
+                    collectRef(ref);
+                }
+            }
+        }
+    }
+    return required;
+}
+function normalizeImportPathForGenerated(specFilePath, generatedFileRelPath, moduleSpecifier) {
+    if (!moduleSpecifier.startsWith(".") && !moduleSpecifier.startsWith("/")) {
+        return moduleSpecifier;
+    }
+    const specDir = node_path_1.default.dirname(specFilePath);
+    const generatedAbs = node_path_1.default.resolve(node_path_1.default.dirname(specFilePath), "generated_output", generatedFileRelPath);
+    const generatedDir = node_path_1.default.dirname(generatedAbs);
+    const resolvedModulePath = node_path_1.default.resolve(specDir, moduleSpecifier);
+    const relative = node_path_1.default.relative(generatedDir, resolvedModulePath);
+    const normalized = relative.split(node_path_1.default.sep).join("/");
+    if (normalized.startsWith("."))
+        return normalized;
+    return `./${normalized}`;
+}
+function renderRequiredTypeImports(spec, generatedFileRelPath) {
+    const requiredSymbols = collectRequiredImportedSymbols(spec);
+    if (requiredSymbols.size === 0)
+        return "";
+    const importLines = [];
+    for (const imp of spec.specImports) {
+        const defaultImport = imp.defaultImport && requiredSymbols.has(imp.defaultImport) ? imp.defaultImport : null;
+        const named = imp.namedImports.filter((n) => requiredSymbols.has(n.localName));
+        if (!defaultImport && named.length === 0)
+            continue;
+        const moduleSpecifier = normalizeImportPathForGenerated(spec.filePath, generatedFileRelPath, imp.moduleSpecifier);
+        const namedClause = named
+            .map((n) => (n.importedName === n.localName ? n.localName : `${n.importedName} as ${n.localName}`))
+            .join(", ");
+        if (defaultImport && named.length > 0) {
+            importLines.push(`import type ${defaultImport}, { ${namedClause} } from "${moduleSpecifier}";`);
+        }
+        else if (defaultImport) {
+            importLines.push(`import type ${defaultImport} from "${moduleSpecifier}";`);
+        }
+        else {
+            importLines.push(`import type { ${namedClause} } from "${moduleSpecifier}";`);
+        }
+    }
+    return importLines.length > 0 ? `${importLines.join("\n")}\n\n` : "";
+}
+function parseTypeDeclNode(nodeText) {
+    const sf = typescript_1.default.createSourceFile("__decl.ts", nodeText, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
+    for (const stmt of sf.statements) {
+        if (typescript_1.default.isInterfaceDeclaration(stmt) || typescript_1.default.isTypeAliasDeclaration(stmt))
+            return stmt;
+    }
+    return null;
+}
+class CppTypeNormalizer {
+    constructor(spec) {
+        this.declMap = new Map();
+        this.seedOrder = [];
+        this.allKnownNames = new Set();
+        this.usedNames = new Set();
+        for (const decl of collectStructDecls(spec)) {
+            this.allKnownNames.add(decl.name);
+            this.usedNames.add(decl.name);
+        }
+    }
+    addSeedDecl(decl) {
+        const node = parseTypeDeclNode(decl.nodeText);
+        if (!node)
+            return;
+        if (this.declMap.has(decl.name))
+            return;
+        const normalized = this.normalizeNamedDecl(decl.name, node);
+        this.declMap.set(decl.name, normalized);
+        this.seedOrder.push(decl.name);
+    }
+    mapTypeText(typeText, nameHintParts) {
+        const node = parseTypeNodeFromText(typeText);
+        return this.mapTypeNode(node, nameHintParts, new Set());
+    }
+    buildContext() {
+        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);
+        return {
+            orderedDecls,
+            structNames,
+            mapTypeText: (typeText, nameHintParts) => this.mapTypeText(typeText, nameHintParts)
+        };
+    }
+    normalizeNamedDecl(name, node) {
+        if (typescript_1.default.isInterfaceDeclaration(node)) {
+            const deps = new Set();
+            const fields = [];
+            for (const member of node.members) {
+                if (!typescript_1.default.isPropertySignature(member) || !member.type || !typescript_1.default.isIdentifier(member.name))
+                    continue;
+                const baseType = this.mapTypeNode(member.type, [name, member.name.text], deps);
+                fields.push({
+                    name: member.name.text,
+                    cppType: baseType,
+                    optional: !!member.questionToken
+                });
+            }
+            return { name, kind: "struct", fields, aliasType: null, deps, isUnionAlias: false };
+        }
+        const deps = new Set();
+        const aliasType = this.mapTypeNode(node.type, [name], deps);
+        return {
+            name,
+            kind: "alias",
+            fields: [],
+            aliasType,
+            deps,
+            isUnionAlias: node.type.getText().includes("|")
+        };
+    }
+    mapTypeNode(typeNode, nameHintParts, deps) {
+        if (typescript_1.default.isParenthesizedTypeNode(typeNode)) {
+            return this.mapTypeNode(typeNode.type, nameHintParts, deps);
+        }
+        if (typescript_1.default.isUnionTypeNode(typeNode)) {
+            return "QString";
+        }
+        if (typescript_1.default.isTypeLiteralNode(typeNode)) {
+            return this.ensureSyntheticStruct(typeNode, nameHintParts, deps);
+        }
+        if (typescript_1.default.isArrayTypeNode(typeNode)) {
+            const itemType = this.mapTypeNode(typeNode.elementType, [...nameHintParts, "Item"], deps);
+            return `QList<${itemType}>`;
+        }
+        if (typescript_1.default.isLiteralTypeNode(typeNode)) {
+            if (typescript_1.default.isStringLiteral(typeNode.literal))
+                return "QString";
+            if (typescript_1.default.isNumericLiteral(typeNode.literal))
+                return "double";
+            if (typeNode.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword || typeNode.literal.kind === typescript_1.default.SyntaxKind.FalseKeyword)
+                return "bool";
+            return "QString";
+        }
+        if (typescript_1.default.isTypeReferenceNode(typeNode)) {
+            const name = qNameText(typeNode.typeName);
+            const rawText = typeNode.getText();
+            if (name.startsWith("AnQst.Type.")) {
+                return mapTsTypeToCpp(rawText);
+            }
+            const args = typeNode.typeArguments ?? [];
+            if ((name === "Array" || name === "ReadonlyArray") && args.length === 1) {
+                const itemType = this.mapTypeNode(args[0], [...nameHintParts, "Item"], deps);
+                return `QList<${itemType}>`;
+            }
+            if (name === "Record")
+                return "QVariantMap";
+            if (name === "Partial" && args.length === 1) {
+                return this.mapTypeNode(args[0], nameHintParts, deps);
+            }
+            if (name === "Promise" && args.length === 1) {
+                return this.mapTypeNode(args[0], nameHintParts, deps);
+            }
+            const mapped = mapTsTypeToCpp(rawText);
+            this.collectKnownTypeDeps(mapped, deps);
+            return mapped;
+        }
+        const mapped = mapTsTypeToCpp(typeNode.getText());
+        this.collectKnownTypeDeps(mapped, deps);
+        return mapped;
+    }
+    ensureSyntheticStruct(typeNode, nameHintParts, deps) {
+        const baseName = this.makeSyntheticBaseName(nameHintParts);
+        const synthesizedName = this.allocateUniqueName(baseName);
+        if (this.declMap.has(synthesizedName)) {
+            deps.add(synthesizedName);
+            return synthesizedName;
+        }
+        this.allKnownNames.add(synthesizedName);
+        const fields = [];
+        const localDeps = new Set();
+        for (const member of typeNode.members) {
+            if (!typescript_1.default.isPropertySignature(member) || !member.type || !typescript_1.default.isIdentifier(member.name))
+                continue;
+            const cppType = this.mapTypeNode(member.type, [...nameHintParts, member.name.text], localDeps);
+            fields.push({
+                name: member.name.text,
+                cppType,
+                optional: !!member.questionToken
+            });
+        }
+        this.declMap.set(synthesizedName, {
+            name: synthesizedName,
+            kind: "struct",
+            fields,
+            aliasType: null,
+            deps: localDeps,
+            isUnionAlias: false
+        });
+        this.seedOrder.push(synthesizedName);
+        deps.add(synthesizedName);
+        return synthesizedName;
+    }
+    collectKnownTypeDeps(cppType, deps) {
+        for (const match of cppType.matchAll(/[A-Za-z_][A-Za-z0-9_]*/g)) {
+            const token = match[0];
+            if (this.allKnownNames.has(token)) {
+                deps.add(token);
+            }
+        }
+    }
+    makeSyntheticBaseName(parts) {
+        const cleaned = parts
+            .map((p) => p.replace(/[^A-Za-z0-9_]/g, "_"))
+            .map((p) => p.replace(/_+/g, "_"))
+            .map((p) => p.replace(/^_+|_+$/g, ""))
+            .filter((p) => p.length > 0);
+        return cleaned.join("_") || "AnonymousType";
+    }
+    allocateUniqueName(baseName) {
+        let candidate = baseName;
+        let i = 2;
+        while (this.usedNames.has(candidate)) {
+            candidate = `${baseName}_${i}`;
+            i += 1;
+        }
+        this.usedNames.add(candidate);
+        return candidate;
+    }
+    topologicalOrder() {
+        const visiting = new Set();
+        const visited = new Set();
+        const ordered = [];
+        const visit = (name) => {
+            if (visited.has(name))
+                return;
+            if (visiting.has(name))
+                return;
+            visiting.add(name);
+            const decl = this.declMap.get(name);
+            if (decl) {
+                for (const dep of [...decl.deps].sort()) {
+                    if (dep === name)
+                        continue;
+                    if (this.declMap.has(dep))
+                        visit(dep);
+                }
+            }
+            visiting.delete(name);
+            visited.add(name);
+            ordered.push(name);
+        };
+        for (const name of this.seedOrder) {
+            visit(name);
+        }
+        return ordered;
+    }
+}
+function renderCppDecl(decl) {
+    if (decl.kind === "alias") {
+        if (decl.isUnionAlias && decl.aliasType === "QString") {
+            return `using ${decl.name} = QString; // union mapped conservatively`;
+        }
+        return `using ${decl.name} = ${decl.aliasType ?? "QString"};`;
+    }
+    const lines = [];
+    lines.push(`struct ${decl.name} {`);
+    for (const field of decl.fields) {
+        const cppType = field.optional ? `std::optional<${field.cppType}>` : field.cppType;
+        lines.push(`    ${cppType} ${field.name};`);
+    }
+    const comparisons = decl.fields.map((f) => `${f.name} == other.${f.name}`);
+    lines.push(`    bool operator==(const ${decl.name}& other) const { return ${comparisons.length > 0 ? comparisons.join(" && ") : "true"}; }`);
+    lines.push("};");
+    return lines.join("\n");
+}
+function buildCppTypeContext(spec) {
+    const normalizer = new CppTypeNormalizer(spec);
+    for (const decl of collectStructDecls(spec)) {
+        normalizer.addSeedDecl(decl);
+    }
+    for (const service of spec.services) {
+        for (const member of service.members) {
+            if (member.payloadTypeText) {
+                normalizer.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]);
+            }
+            for (const param of member.parameters) {
+                normalizer.mapTypeText(param.typeText, [service.name, member.name, param.name]);
+            }
+        }
+    }
+    return normalizer.buildContext();
+}
+function renderTypesHeader(spec, cppTypes) {
+    const decls = cppTypes.orderedDecls.map(renderCppDecl).join("\n\n");
+    const metatypes = cppTypes.structNames
+        .flatMap((name) => [
+        `Q_DECLARE_METATYPE(${spec.widgetName}::${name})`,
+        `Q_DECLARE_METATYPE(QList<${spec.widgetName}::${name}>)`
+    ])
+        .join("\n");
+    return `#pragma once
+#include <QString>
+#include <QStringList>
+#include <QList>
+#include <QVariantMap>
+#include <QMetaType>
+#include <cstdint>
+#include <optional>
+
+namespace ${spec.widgetName} {
+
+${decls}
+
+} // namespace ${spec.widgetName}
+
+${metatypes}
+`;
+}
+function renderWidgetHeader(spec, cppTypes) {
+    const callbackAliases = [];
+    const publicMethods = [];
+    const signals = [];
+    const properties = [];
+    const fields = [];
+    const outputSetters = [];
+    const bindings = [];
+    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"]);
+                const args = member.parameters.map((p) => `${cppTypes.mapTypeText(p.typeText, [service.name, member.name, p.name])} ${p.name}`).join(", ");
+                callbackAliases.push(`using ${memberPascal}Handler = std::function<${cppType}(${args})>;`);
+                publicMethods.push(`void set${memberPascal}Handler(const ${memberPascal}Handler& handler);`);
+                fields.push(`${memberPascal}Handler m_${member.name}Handler;`);
+            }
+            else if (member.kind === "Emitter") {
+                const args = member.parameters.map((p) => `${cppTypes.mapTypeText(p.typeText, [service.name, member.name, p.name])} ${p.name}`).join(", ");
+                callbackAliases.push(`using ${memberPascal}Handler = std::function<void(${args})>;`);
+                publicMethods.push(`void set${memberPascal}Handler(const ${memberPascal}Handler& handler);`);
+                fields.push(`${memberPascal}Handler m_${member.name}Handler;`);
+            }
+            else if (member.kind === "Slot") {
+                const ret = member.payloadTypeText ? cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]) : "void";
+                const args = member.parameters.map((p) => `${cppTypes.mapTypeText(p.typeText, [service.name, member.name, p.name])} ${p.name}`).join(", ");
+                publicMethods.push(`${ret} ${member.name}(${args}${args ? ", " : ""}bool* ok = nullptr, QString* error = nullptr);`);
+            }
+            else if ((member.kind === "Input" || member.kind === "Output") && member.payloadTypeText) {
+                const cppType = cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]);
+                const cap = member.name.charAt(0).toUpperCase() + member.name.slice(1);
+                properties.push(`Q_PROPERTY(${cppType} ${member.name} READ ${member.name} WRITE set${cap} NOTIFY ${member.name}Changed)`);
+                publicMethods.push(`${cppType} ${member.name}() const;`);
+                publicMethods.push(`void set${cap}(const ${cppType}& value);`);
+                signals.push(`void ${member.name}Changed(const ${cppType}& value);`);
+                fields.push(`${cppType} m_${member.name}{};`);
+                if (member.kind === "Input") {
+                    callbackAliases.push(`using ${memberPascal}Handler = std::function<void(const ${cppType}& value)>;`);
+                    publicMethods.push(`void set${memberPascal}Handler(const ${memberPascal}Handler& handler);`);
+                    fields.push(`${memberPascal}Handler m_${member.name}Handler;`);
+                }
+                else {
+                    outputSetters.push(`void publish${memberPascal}(const ${cppType}& value);`);
+                }
+            }
+        }
+    }
+    return `#pragma once
+#include <QHash>
+#include <QVariant>
+#include <QVariantList>
+#include <functional>
+#include "AnQstWebHostBase.h"
+#include "${spec.widgetName}Types.h"
+
+namespace ${spec.widgetName} {
+
+class ${spec.widgetName} : public AnQstWebHostBase {
+    Q_OBJECT
+${properties.map((p) => `    ${p}`).join("\n")}
+
+public:
+    explicit ${spec.widgetName}(QWidget* parent = nullptr);
+    ~${spec.widgetName}() override;
+    bool enableDebug();
+    static constexpr const char* kBootstrapEntryPoint = "index.html";
+    static constexpr const char* kBootstrapContentRoot = "qrc:/${spec.widgetName.toLowerCase()}";
+    static constexpr const char* kBootstrapBridgeObject = "${spec.widgetName}Bridge";
+
+${callbackAliases.map((s) => `    ${s}`).join("\n")}
+${publicMethods.map((s) => `    ${s}`).join("\n")}
+${outputSetters.map((s) => `    ${s}`).join("\n")}
+
+signals:
+${signals.map((s) => `    ${s}`).join("\n")}
+    void diagnosticsForwarded(const QVariantMap& payload);
+
+private:
+    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();
+    QVariant handleGeneratedCall(const QString& service, const QString& member, const QVariantList& args);
+    void handleGeneratedEmitter(const QString& service, const QString& member, const QVariantList& args);
+    void handleGeneratedInput(const QString& service, const QString& member, const QVariant& value);
+
+${fields.map((f) => `    ${f}`).join("\n")}
+};
+
+} // namespace ${spec.widgetName}
+`;
+}
+function renderCppStub(spec, cppTypes) {
+    const lines = [];
+    lines.push(`#include "include/${spec.widgetName}.h"`);
+    lines.push(`#include <QDebug>`);
+    lines.push(`#include <QMetaType>`);
+    lines.push("");
+    lines.push(`extern int qInitResources_${spec.widgetName}();`);
+    lines.push("");
+    lines.push("namespace {");
+    lines.push("void registerGeneratedMetaTypes() {");
+    lines.push("    static const bool registered = []() {");
+    for (const typeName of cppTypes.structNames) {
+        lines.push(`        qRegisterMetaType<${spec.widgetName}::${typeName}>("${spec.widgetName}::${typeName}");`);
+        lines.push(`        qRegisterMetaType<QList<${spec.widgetName}::${typeName}>>("QList<${spec.widgetName}::${typeName}>");`);
+    }
+    lines.push("        return true;");
+    lines.push("    }();");
+    lines.push("    Q_UNUSED(registered);");
+    lines.push("}");
+    lines.push("}");
+    lines.push("");
+    lines.push(`namespace ${spec.widgetName} {`);
+    lines.push("");
+    lines.push(`const ${spec.widgetName}::BridgeBindingRow ${spec.widgetName}::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(`${spec.widgetName}::${spec.widgetName}(QWidget* parent) : AnQstWebHostBase(parent) {`);
+    lines.push(`    static const bool kResourcesInitialized = []() {`);
+    lines.push(`        ::qInitResources_${spec.widgetName}();`);
+    lines.push(`        return true;`);
+    lines.push(`    }();`);
+    lines.push(`    Q_UNUSED(kResourcesInitialized);`);
+    lines.push(`    registerGeneratedMetaTypes();`);
+    lines.push(`    installBridgeBindings();`);
+    lines.push(`    QObject::connect(this, &AnQstWebHostBase::onHostError, this, &${spec.widgetName}::diagnosticsForwarded);`);
+    lines.push(`    const bool rootOk = setContentRoot(QString::fromUtf8(kBootstrapContentRoot));`);
+    lines.push(`    const bool bridgeOk = setBridgeObject(this, QString::fromUtf8(kBootstrapBridgeObject));`);
+    lines.push(`    const bool loadOk = rootOk && bridgeOk && loadEntryPoint(QString::fromUtf8(kBootstrapEntryPoint));`);
+    lines.push(`    if (!loadOk) {`);
+    lines.push(`        qWarning() << "${spec.widgetName} bootstrap failed.";`);
+    lines.push(`    }`);
+    lines.push("}");
+    lines.push("");
+    lines.push(`${spec.widgetName}::~${spec.widgetName}() = default;`);
+    lines.push("");
+    lines.push(`bool ${spec.widgetName}::enableDebug() {`);
+    lines.push(`    return AnQstWebHostBase::enableDebug();`);
+    lines.push("}");
+    lines.push("");
+    lines.push(`QString ${spec.widgetName}::makeBindingKey(const QString& service, const QString& member) {`);
+    lines.push(`    return service + QStringLiteral("::") + member;`);
+    lines.push(`}`);
+    lines.push("");
+    lines.push(`void ${spec.widgetName}::installBridgeBindings() {`);
+    lines.push(`    setCallHandler([this](const QString& service, const QString& member, const QVariantList& args) -> QVariant {`);
+    lines.push(`        return handleGeneratedCall(service, member, args);`);
+    lines.push(`    });`);
+    lines.push(`    setEmitterHandler([this](const QString& service, const QString& member, const QVariantList& args) {`);
+    lines.push(`        handleGeneratedEmitter(service, member, args);`);
+    lines.push(`    });`);
+    lines.push(`    setInputHandler([this](const QString& service, const QString& member, const QVariant& value) {`);
+    lines.push(`        handleGeneratedInput(service, member, value);`);
+    lines.push(`    });`);
+    lines.push(`}`);
+    lines.push("");
+    lines.push(`QVariant ${spec.widgetName}::handleGeneratedCall(const QString& service, const QString& member, const QVariantList& args) {`);
+    for (const service of spec.services) {
+        for (const member of service.members) {
+            if (member.kind !== "Call" || !member.payloadTypeText)
+                continue;
+            const cppType = cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]);
+            const pascal = pascalCase(member.name);
+            lines.push(`    if (service == QStringLiteral("${service.name}") && member == QStringLiteral("${member.name}")) {`);
+            lines.push(`        if (!m_${member.name}Handler) return QVariant();`);
+            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 argNames = member.parameters.map((p) => p.name).join(", ");
+            lines.push(`        const ${cppType} result = m_${member.name}Handler(${argNames});`);
+            lines.push(`        return ${cppToVariantExpression(cppType, "result")};`);
+            lines.push(`    }`);
+        }
+    }
+    lines.push(`    return QVariant();`);
+    lines.push(`}`);
+    lines.push("");
+    lines.push(`void ${spec.widgetName}::handleGeneratedEmitter(const QString& service, const QString& member, const QVariantList& args) {`);
+    for (const service of spec.services) {
+        for (const member of service.members) {
+            if (member.kind !== "Emitter")
+                continue;
+            lines.push(`    if (service == QStringLiteral("${service.name}") && member == QStringLiteral("${member.name}")) {`);
+            lines.push(`        if (!m_${member.name}Handler) return;`);
+            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 argNames = member.parameters.map((p) => p.name).join(", ");
+            lines.push(`        m_${member.name}Handler(${argNames});`);
+            lines.push(`        return;`);
+            lines.push(`    }`);
+        }
+    }
+    lines.push(`}`);
+    lines.push("");
+    lines.push(`void ${spec.widgetName}::handleGeneratedInput(const QString& service, const QString& member, const QVariant& value) {`);
+    for (const service of spec.services) {
+        for (const member of service.members) {
+            if (member.kind !== "Input" || !member.payloadTypeText)
+                continue;
+            const cppType = cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]);
+            lines.push(`    if (service == QStringLiteral("${service.name}") && member == QStringLiteral("${member.name}")) {`);
+            lines.push(`        const ${cppType} typedValue = ${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;`);
+            lines.push(`    }`);
+        }
+    }
+    lines.push(`}`);
+    lines.push("");
+    for (const service of spec.services) {
+        for (const member of service.members) {
+            const memberPascal = pascalCase(member.name);
+            if ((member.kind === "Call" || member.kind === "Input") && member.payloadTypeText) {
+                lines.push(`void ${spec.widgetName}::set${memberPascal}Handler(const ${memberPascal}Handler& handler) {`);
+                lines.push(`    m_${member.name}Handler = handler;`);
+                lines.push("}");
+                lines.push("");
+            }
+            else if (member.kind === "Emitter") {
+                lines.push(`void ${spec.widgetName}::set${memberPascal}Handler(const ${memberPascal}Handler& handler) {`);
+                lines.push(`    m_${member.name}Handler = handler;`);
+                lines.push("}");
+                lines.push("");
+            }
+            else if (member.kind === "Input" && member.payloadTypeText) {
+                lines.push(`void ${spec.widgetName}::set${memberPascal}Handler(const ${memberPascal}Handler& handler) {`);
+                lines.push(`    m_${member.name}Handler = handler;`);
+                lines.push("}");
+                lines.push("");
+            }
+            if (member.kind === "Slot") {
+                const ret = member.payloadTypeText ? cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]) : "void";
+                const args = member.parameters.map((p) => `${cppTypes.mapTypeText(p.typeText, [service.name, member.name, p.name])} ${p.name}`).join(", ");
+                const argsWithMeta = `${args}${args ? ", " : ""}bool* ok, QString* error`;
+                lines.push(`${ret} ${spec.widgetName}::${member.name}(${argsWithMeta}) {`);
+                lines.push(`    QVariantList invokeArgs;`);
+                for (const p of member.parameters) {
+                    const pType = mapTsTypeToCpp(p.typeText);
+                    lines.push(`    invokeArgs.push_back(${cppToVariantExpression(pType, p.name)});`);
+                }
+                lines.push(`    QVariant result;`);
+                lines.push(`    QString invokeError;`);
+                lines.push(`    const bool success = invokeSlot(QStringLiteral("${service.name}"), QStringLiteral("${member.name}"), invokeArgs, &result, &invokeError);`);
+                lines.push(`    if (ok != nullptr) *ok = success;`);
+                lines.push(`    if (error != nullptr) *error = invokeError;`);
+                if (ret === "void") {
+                    lines.push(`    if (!success) return;`);
+                    lines.push(`    return;`);
+                }
+                else {
+                    lines.push(`    if (!success) return ${ret}{};`);
+                    lines.push(`    return ${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 cap = member.name.charAt(0).toUpperCase() + member.name.slice(1);
+                lines.push(`${cppType} ${spec.widgetName}::${member.name}() const {`);
+                lines.push(`    return m_${member.name};`);
+                lines.push("}");
+                lines.push("");
+                lines.push(`void ${spec.widgetName}::set${cap}(const ${cppType}& value) {`);
+                lines.push(`    if (m_${member.name} == value) return;`);
+                lines.push(`    m_${member.name} = value;`);
+                if (member.kind === "Output") {
+                    lines.push(`    setOutputValue(QStringLiteral("${service.name}"), QStringLiteral("${member.name}"), ${cppToVariantExpression(cppType, "value")});`);
+                }
+                lines.push(`    emit ${member.name}Changed(value);`);
+                lines.push("}");
+                lines.push("");
+                if (member.kind === "Output") {
+                    lines.push(`void ${spec.widgetName}::publish${pascalCase(member.name)}(const ${cppType}& value) {`);
+                    lines.push(`    set${cap}(value);`);
+                    lines.push(`}`);
+                    lines.push("");
+                }
+            }
+        }
+    }
+    lines.push(`} // namespace ${spec.widgetName}`);
+    return lines.join("\n");
+}
+function renderCMake(spec) {
+    return `cmake_minimum_required(VERSION 3.21)
+project(${spec.widgetName}Library LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTORCC ON)
+
+if(NOT TARGET anqstwebhostbase)
+    message(FATAL_ERROR "Target 'anqstwebhostbase' is required before adding generated widget library ${spec.widgetName}Widget.")
+endif()
+
+add_library(${spec.widgetName}Widget
+    ${spec.widgetName}.cpp
+    ${spec.widgetName}.qrc
+    include/${spec.widgetName}.h
+    include/${spec.widgetName}Types.h
+)
+target_include_directories(${spec.widgetName}Widget
+    PUBLIC
+        \${CMAKE_CURRENT_SOURCE_DIR}/include
+)
+target_link_libraries(${spec.widgetName}Widget
+    PUBLIC
+        anqstwebhostbase
+)
+
+# Uses transitive Qt and include requirements from anqstwebhostbase.
+`;
+}
+function escapeXml(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/"/g, "&quot;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+function normalizeSlashes(value) {
+    return value.split(node_path_1.default.sep).join("/");
+}
+function renderEmbeddedQrc(widgetName, embeddedWebFiles) {
+    const files = [...embeddedWebFiles].sort();
+    const lines = [];
+    lines.push("<RCC>");
+    lines.push(`    <qresource prefix="/${widgetName.toLowerCase()}">`);
+    if (files.length === 0) {
+        lines.push("        <!-- anqst build will populate embedded web assets under webapp/ -->");
+    }
+    for (const relPath of files) {
+        lines.push(`        <file alias="${escapeXml(relPath)}">webapp/${escapeXml(relPath)}</file>`);
+    }
+    lines.push("    </qresource>");
+    lines.push("</RCC>");
+    return `${lines.join("\n")}\n`;
+}
+function renderNpmPackage(spec) {
+    return JSON.stringify({
+        name: `${spec.widgetName.toLowerCase()}-generated`,
+        version: "0.1.0",
+        private: true,
+        types: "types/index.d.ts",
+        main: "services.js",
+        exports: {
+            ".": {
+                types: "./types/index.d.ts",
+                default: "./index.js"
+            },
+            "./services": {
+                types: "./types/services.d.ts",
+                default: "./services.js"
+            },
+            "./types": {
+                types: "./types/types.d.ts",
+                default: "./types.js"
+            }
+        },
+        anqst: {
+            widget: spec.widgetName,
+            services: spec.services.map((s) => s.name),
+            supportsDevelopmentModeTransport: spec.supportsDevelopmentModeTransport
+        }
+    }, null, 2);
+}
+function renderTypeDeclarations(spec, exported = false) {
+    const decls = collectReachableNamespaceDecls(spec)
+        .map((d) => {
+        const normalized = stripAnQstType(d.nodeText);
+        if (!exported)
+            return normalized;
+        return normalized.replace(/^(\s*)(interface|type)\b/m, "$1export $2");
+    })
+        .join("\n\n");
+    if (decls.trim().length === 0)
+        return "";
+    return `${decls}\n`;
+}
+function renderLocalTypeImports(spec) {
+    const localTypeNames = collectReachableNamespaceDecls(spec).map((decl) => decl.name);
+    if (localTypeNames.length === 0)
+        return "";
+    return `import type { ${localTypeNames.join(", ")} } from "./types";`;
+}
+function renderTsService(spec, serviceName) {
+    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}]` : "[]";
+        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}); }`);
+            continue;
+        }
+        if (m.kind === "Emitter") {
+            methodLines.push(`  ${m.name}(${args}): void { this._bridge.emit("${serviceName}", "${m.name}", ${valueArray}); }`);
+            continue;
+        }
+        if (m.kind === "Slot") {
+            const ret = mapTypeTextToTs(m.payloadTypeText ?? "void");
+            onSlotMembers.push(`    ${m.name}: (handler: (${args}) => ${ret}): void => {`);
+            onSlotMembers.push(`      this._bridge.registerSlot("${serviceName}", "${m.name}", handler as (...args: unknown[]) => unknown);`);
+            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}(); }`);
+            if (m.kind === "Input") {
+                setMembers.push(`    ${m.name}: (value: ${tsType}): void => {`);
+                setMembers.push(`      this._${m.name}.set(value);`);
+                setMembers.push(`      this._bridge.setInput("${serviceName}", "${m.name}", value);`);
+                setMembers.push("    },");
+            }
+            if (m.kind === "Output") {
+                constructorBodyLines.push(`    this._bridge.onOutput("${serviceName}", "${m.name}", (value) => this._${m.name}.set(value as ${tsType}));`);
+            }
+        }
+    }
+    const constructorLines = [
+        "  constructor() {",
+        ...constructorBodyLines,
+        "  }",
+    ];
+    return `@Injectable({ providedIn: "root" })
+export class ${serviceName} {
+  private readonly _bridge = inject(AnQstBridgeRuntime);
+${fieldLines.join("\n")}
+${constructorLines.join("\n")}
+  readonly set = {
+${setMembers.join("\n")}
+  };
+  readonly onSlot = {
+${onSlotMembers.join("\n")}
+  };
+${methodLines.join("\n")}
+}
+`;
+}
+function renderTsServiceDts(spec, serviceName) {
+    const members = spec.services.find((s) => s.name === serviceName)?.members ?? [];
+    const setMembers = [];
+    const onSlotMembers = [];
+    const classMembers = [];
+    const setInterfaceName = `${serviceName}Set`;
+    const onSlotInterfaceName = `${serviceName}OnSlot`;
+    for (const m of members) {
+        const args = m.parameters.map((p) => `${p.name}: ${mapTypeTextToTs(p.typeText)}`).join(", ");
+        if (m.kind === "Call") {
+            const ret = mapTypeTextToTs(m.payloadTypeText ?? "void");
+            classMembers.push(`  ${m.name}(${args}): Promise<${ret}>;`);
+            continue;
+        }
+        if (m.kind === "Emitter") {
+            classMembers.push(`  ${m.name}(${args}): void;`);
+            continue;
+        }
+        if (m.kind === "Slot") {
+            const ret = mapTypeTextToTs(m.payloadTypeText ?? "void");
+            onSlotMembers.push(`  ${m.name}(handler: (${args}) => ${ret}): void;`);
+            continue;
+        }
+        if ((m.kind === "Input" || m.kind === "Output") && m.payloadTypeText) {
+            const tsType = mapTypeTextToTs(m.payloadTypeText);
+            classMembers.push(`  ${m.name}(): ${tsType};`);
+            if (m.kind === "Input") {
+                setMembers.push(`  ${m.name}(value: ${tsType}): void;`);
+            }
+        }
+    }
+    const setInterfaceDecl = setMembers.length > 0
+        ? `export interface ${setInterfaceName} {\n${setMembers.join("\n")}\n}`
+        : `export interface ${setInterfaceName} {}`;
+    const onSlotInterfaceDecl = onSlotMembers.length > 0
+        ? `export interface ${onSlotInterfaceName} {\n${onSlotMembers.join("\n")}\n}`
+        : `export interface ${onSlotInterfaceName} {}`;
+    const classMemberBlock = classMembers.length > 0 ? `\n${classMembers.join("\n")}` : "";
+    return `${setInterfaceDecl}
+
+${onSlotInterfaceDecl}
+
+export declare class ${serviceName} {
+  readonly set: ${setInterfaceName};
+  readonly onSlot: ${onSlotInterfaceName};${classMemberBlock}
+}`;
+}
+function renderTsServices(spec) {
+    const serviceClasses = spec.services.map((s) => renderTsService(spec, s.name)).join("\n");
+    const externalTypeImports = renderRequiredTypeImports(spec, "npmpackage/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` : "";
+    return `import { Injectable, inject, signal } from "@angular/core";
+${typeImportsBlock}
+
+type SlotHandler = (...args: unknown[]) => unknown;
+type OutputHandler = (value: unknown) => void;
+type SlotInvocationListener = (requestId: string, service: string, member: string, args: unknown[]) => void;
+type OutputListener = (service: string, member: string, value: unknown) => void;
+
+interface HostBridgeApi {
+  anQstBridge_call(service: string, member: string, args: unknown[], callback: (result: unknown) => void): void;
+  anQstBridge_emit(service: string, member: string, args: unknown[]): void;
+  anQstBridge_setInput(service: string, member: string, value: unknown): void;
+  anQstBridge_registerSlot(service: string, member: string): void;
+  anQstBridge_resolveSlot(requestId: string, ok: boolean, payload: unknown, error: string): void;
+  anQstBridge_outputUpdated: { connect: (cb: (service: string, member: string, value: unknown) => void) => void };
+  anQstBridge_slotInvocationRequested: {
+    connect: (cb: (requestId: string, service: string, member: string, args: unknown[]) => void) => void;
+  };
+}
+
+interface QWebChannelCtor {
+  new (
+    transport: unknown,
+    initCallback: (channel: { objects: Record<string, HostBridgeApi | undefined> }) => void
+  ): unknown;
+}
+
+interface BridgeAdapter {
+  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;
+  registerSlot(service: string, member: string): void;
+  resolveSlot(requestId: string, ok: boolean, payload: unknown, error: string): void;
+  onOutput(handler: OutputListener): void;
+  onSlotInvocation(handler: SlotInvocationListener): void;
+}
+
+class QtWebChannelAdapter implements BridgeAdapter {
+  private constructor(private readonly host: HostBridgeApi) {}
+
+  static async create(): Promise<QtWebChannelAdapter> {
+    const anyWindow = window as unknown as {
+      qt?: { webChannelTransport?: unknown };
+      QWebChannel?: QWebChannelCtor;
+    };
+    if (typeof anyWindow.QWebChannel !== "function" || anyWindow.qt?.webChannelTransport === undefined) {
+      throw new Error("Qt WebChannel transport is unavailable.");
+    }
+    return await new Promise<QtWebChannelAdapter>((resolve, reject) => {
+      try {
+        const QWebChannel = anyWindow.QWebChannel as QWebChannelCtor;
+        new QWebChannel(anyWindow.qt!.webChannelTransport, (channel) => {
+          try {
+            const host = channel.objects["${spec.widgetName}Bridge"];
+            if (host === undefined) {
+              reject(new Error("${spec.widgetName}Bridge bridge object is unavailable."));
+              return;
+            }
+            resolve(new QtWebChannelAdapter(host));
+          } catch (error) {
+            reject(error instanceof Error ? error : new Error(String(error)));
+          }
+        });
+      } catch (error) {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+
+  async call<T>(service: string, member: string, args: unknown[]): Promise<T> {
+    return new Promise<T>((resolve) => {
+      this.host.anQstBridge_call(service, member, args, (result) => resolve(result as T));
+    });
+  }
+
+  emit(service: string, member: string, args: unknown[]): void {
+    this.host.anQstBridge_emit(service, member, args);
+  }
+
+  setInput(service: string, member: string, value: unknown): void {
+    this.host.anQstBridge_setInput(service, member, value);
+  }
+
+  registerSlot(service: string, member: string): void {
+    this.host.anQstBridge_registerSlot(service, member);
+  }
+
+  resolveSlot(requestId: string, ok: boolean, payload: unknown, error: string): void {
+    this.host.anQstBridge_resolveSlot(requestId, ok, payload, error);
+  }
+
+  onOutput(handler: OutputListener): void {
+    this.host.anQstBridge_outputUpdated.connect(handler);
+  }
+
+  onSlotInvocation(handler: SlotInvocationListener): void {
+    this.host.anQstBridge_slotInvocationRequested.connect(handler);
+  }
+}
+
+class WebSocketBridgeAdapter implements BridgeAdapter {
+  private readonly pending = new Map<string, (result: unknown) => void>();
+  private readonly outputListeners: OutputListener[] = [];
+  private readonly slotListeners: SlotInvocationListener[] = [];
+  private requestCounter = 0;
+
+  private constructor(private readonly socket: WebSocket) {
+    this.socket.addEventListener("message", (event) => {
+      const raw = typeof event.data === "string" ? event.data : String(event.data);
+      const message = JSON.parse(raw) as Record<string, unknown>;
+      const type = String(message["type"] ?? "");
+      if (type === "callResult") {
+        const requestId = String(message["requestId"] ?? "");
+        const resolver = this.pending.get(requestId);
+        if (resolver) {
+          this.pending.delete(requestId);
+          resolver(message["result"]);
+        }
+        return;
+      }
+      if (type === "outputUpdated") {
+        const service = String(message["service"] ?? "");
+        const member = String(message["member"] ?? "");
+        for (const listener of this.outputListeners) {
+          listener(service, member, message["value"]);
+        }
+        return;
+      }
+      if (type === "slotInvocationRequested") {
+        const requestId = String(message["requestId"] ?? "");
+        const service = String(message["service"] ?? "");
+        const member = String(message["member"] ?? "");
+        const args = Array.isArray(message["args"]) ? (message["args"] as unknown[]) : [];
+        for (const listener of this.slotListeners) {
+          listener(requestId, service, member, args);
+        }
+        return;
+      }
+      if (type === "hostError") {
+        console.error("AnQst host error:", message["payload"]);
+      }
+    });
+  }
+
+  static async create(): Promise<WebSocketBridgeAdapter> {
+    const configResponse = await fetch("/anqst-dev-config.json", { cache: "no-store" });
+    if (!configResponse.ok) {
+      throw new Error("AnQst host bootstrap missing: unable to read /anqst-dev-config.json");
+    }
+    const config = (await configResponse.json()) as { wsUrl?: string };
+    if (!config.wsUrl) {
+      throw new Error("AnQst host bootstrap missing: wsUrl is unavailable.");
+    }
+    return await new Promise<WebSocketBridgeAdapter>((resolve, reject) => {
+      const socket = new WebSocket(config.wsUrl!);
+      socket.addEventListener("open", () => resolve(new WebSocketBridgeAdapter(socket)));
+      socket.addEventListener("error", () => reject(new Error("Failed to connect to AnQst WebSocket bridge.")));
+    });
+  }
+
+  async call<T>(service: string, member: string, args: unknown[]): Promise<T> {
+    const requestId = \`req-\${++this.requestCounter}\`;
+    const payload = { type: "call", requestId, service, member, args };
+    return await new Promise<T>((resolve) => {
+      this.pending.set(requestId, (value) => resolve(value as T));
+      this.socket.send(JSON.stringify(payload));
+    });
+  }
+
+  emit(service: string, member: string, args: unknown[]): void {
+    this.socket.send(JSON.stringify({ type: "emit", service, member, args }));
+  }
+
+  setInput(service: string, member: string, value: unknown): void {
+    this.socket.send(JSON.stringify({ type: "setInput", service, member, value }));
+  }
+
+  registerSlot(service: string, member: string): void {
+    this.socket.send(JSON.stringify({ type: "registerSlot", service, member }));
+  }
+
+  resolveSlot(requestId: string, ok: boolean, payload: unknown, error: string): void {
+    this.socket.send(JSON.stringify({ type: "resolveSlot", requestId, ok, payload, error }));
+  }
+
+  onOutput(handler: OutputListener): void {
+    this.outputListeners.push(handler);
+  }
+
+  onSlotInvocation(handler: SlotInvocationListener): void {
+    this.slotListeners.push(handler);
+  }
+}
+
+@Injectable({ providedIn: "root" })
+class AnQstBridgeRuntime {
+  private adapter: BridgeAdapter | null = null;
+  private readonly slotHandlers = new Map<string, SlotHandler>();
+  private readonly outputHandlers = new Map<string, OutputHandler[]>();
+  private readonly startup = this.init();
+
+  async ready(): Promise<void> {
+    return this.startup;
+  }
+
+  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));
+  }
+
+  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));
+  }
+
+  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);
+      return;
+    }
+    this.ready()
+      .then(() => this.requireAdapterSync().registerSlot(service, member))
+      .catch((error) => console.error(error));
+  }
+
+  onOutput(service: string, member: string, handler: OutputHandler): void {
+    const key = this.key(service, member);
+    const existing = this.outputHandlers.get(key) ?? [];
+    existing.push(handler);
+    this.outputHandlers.set(key, existing);
+  }
+
+  private requireAdapterSync(): BridgeAdapter {
+    if (this.adapter === null) {
+      throw new Error("AnQst bridge is not ready.");
+    }
+    return this.adapter;
+  }
+
+  private async requireAdapter(): Promise<BridgeAdapter> {
+    await this.startup;
+    return this.requireAdapterSync();
+  }
+
+  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) {
+      this.adapter = await QtWebChannelAdapter.create();
+    } else {
+      this.adapter = await WebSocketBridgeAdapter.create();
+    }
+
+    this.adapter.onOutput((service, member, value) => {
+      const key = this.key(service, member);
+      for (const outputHandler of this.outputHandlers.get(key) ?? []) {
+        outputHandler(value);
+      }
+    });
+    this.adapter.onSlotInvocation((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.");
+        return;
+      }
+      try {
+        const result = handler(...args);
+        this.adapter!.resolveSlot(requestId, true, result, "");
+      } catch (error) {
+        this.adapter!.resolveSlot(requestId, false, undefined, String(error));
+      }
+    });
+    for (const key of this.slotHandlers.keys()) {
+      const parts = key.split("::");
+      if (parts.length === 2) {
+        this.adapter.registerSlot(parts[0], parts[1]);
+      }
+    }
+  }
+
+  private key(service: string, member: string): string {
+    return \`\${service}::\${member}\`;
+  }
+
+}
+${serviceClasses}
+`;
+}
+function renderTsTypes(spec) {
+    const typeImports = renderRequiredTypeImports(spec, "npmpackage/types.ts").trim();
+    const typeDecls = renderTypeDeclarations(spec, true).trim();
+    const sections = [typeImports, typeDecls].filter((s) => s.length > 0);
+    return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
+}
+function renderTypeServicesDts(spec) {
+    const externalTypeImports = renderRequiredTypeImports(spec, "npmpackage/types/services.d.ts").trim();
+    const localTypeImports = renderLocalTypeImports(spec).trim();
+    const serviceDecls = spec.services
+        .map((s) => renderTsServiceDts(spec, s.name))
+        .join("\n\n");
+    const sections = [externalTypeImports, localTypeImports, serviceDecls.trim()].filter((s) => s.length > 0);
+    return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
+}
+function renderTypeTypesDts(spec) {
+    const typeImports = renderRequiredTypeImports(spec, "npmpackage/types/types.d.ts").trim();
+    const typeDecls = renderTypeDeclarations(spec, true).trim();
+    const sections = [typeImports, typeDecls].filter((s) => s.length > 0);
+    return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
+}
+function renderTsIndex() {
+    return `export type Services = typeof import("./services");
+export type Types = typeof import("./types");
+`;
+}
+function renderTypeIndexDts() {
+    return `export type Services = typeof import("../services");
+export type Types = typeof import("../types");
+`;
+}
+function renderJsModule() {
+    return `"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+`;
+}
+function renderJsIndex() {
+    return renderJsModule();
+}
+function renderJsServices() {
+    return renderJsModule();
+}
+function renderJsTypes() {
+    return renderJsModule();
+}
+function renderNodeExpressWsPackage(spec) {
+    return JSON.stringify({
+        name: `${spec.widgetName.toLowerCase()}-node-express-ws-generated`,
+        version: "0.1.0",
+        private: true,
+        types: "types/index.d.ts",
+        main: "index.ts",
+        exports: {
+            ".": {
+                types: "./types/index.d.ts",
+                default: "./index.ts"
+            }
+        },
+        anqst: {
+            widget: spec.widgetName,
+            services: spec.services.map((s) => s.name),
+            target: "node_express_ws"
+        }
+    }, null, 2);
+}
+function nodeParamTuple(member) {
+    if (member.parameters.length === 0)
+        return "[]";
+    return `[${member.parameters.map((p) => mapTypeTextToTs(p.typeText)).join(", ")}]`;
+}
+function nodeParamArgs(member) {
+    return member.parameters.map((p) => `${p.name}: ${mapTypeTextToTs(p.typeText)}`).join(", ");
+}
+function nodeParamValues(member) {
+    if (member.parameters.length === 0)
+        return "[]";
+    return `[${member.parameters.map((p) => p.name).join(", ")}]`;
+}
+function nodeCap(value) {
+    return value.length === 0 ? value : `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+function renderNodeExpressWsTypes(spec) {
+    const typeImports = renderRequiredTypeImports(spec, `${generatedNodeExpressWsDirName(spec.widgetName)}/types/index.d.ts`).trim();
+    const typeDecls = renderTypeDeclarations(spec, true).trim();
+    const sections = [typeImports, typeDecls].filter((s) => s.length > 0);
+    return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
+}
+function renderNodeExpressWsIndex(spec) {
+    const typeImports = renderRequiredTypeImports(spec, `${generatedNodeExpressWsDirName(spec.widgetName)}/index.ts`);
+    const typeDecls = renderTypeDeclarations(spec, true);
+    const handlerBridgeTypeName = `${spec.widgetName}HandlerBridge`;
+    const sessionBridgeTypeName = `${spec.widgetName}SessionBridge`;
+    const handlerInterfaces = spec.services
+        .map((service) => {
+        const lines = [];
+        for (const member of service.members) {
+            const args = nodeParamArgs(member);
+            const prefixedArgs = args.length > 0 ? `, ${args}` : "";
+            if (member.kind === "Call" && member.payloadTypeText) {
+                const ret = mapTypeTextToTs(member.payloadTypeText);
+                lines.push(`  ${member.name}(bridge: ${handlerBridgeTypeName}${prefixedArgs}): ${ret} | Promise<${ret}>;`);
+            }
+            else if (member.kind === "Emitter") {
+                lines.push(`  ${member.name}(bridge: ${handlerBridgeTypeName}${prefixedArgs}): void | Promise<void>;`);
+            }
+            else if (member.kind === "Input" && member.payloadTypeText) {
+                lines.push(`  ${member.name}(bridge: ${handlerBridgeTypeName}, value: ${mapTypeTextToTs(member.payloadTypeText)}): void | Promise<void>;`);
+            }
+        }
+        return `export interface ${service.name}NodeHandlers {\n${lines.join("\n")}\n}`;
+    })
+        .join("\n\n");
+    const implementationFields = spec.services.map((service) => `  ${service.name}: ${service.name}NodeHandlers;`).join("\n");
+    const slotHelpers = spec.services
+        .flatMap((service) => service.members
+        .filter((member) => member.kind === "Slot")
+        .map((member) => {
+        const ret = mapTypeTextToTs(member.payloadTypeText ?? "void");
+        const args = nodeParamArgs(member);
+        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}>;
+  }`;
+    }))
+        .join("\n");
+    const outputHelpers = spec.services
+        .flatMap((service) => service.members
+        .filter((member) => member.kind === "Output" && member.payloadTypeText)
+        .map((member) => {
+        const typeText = mapTypeTextToTs(member.payloadTypeText);
+        return `  set${service.name}_${nodeCap(member.name)}(value: ${typeText}): void {
+    this.setOutputValue("${service.name}", "${member.name}", value);
+  }`;
+    }))
+        .join("\n");
+    const sessionServiceInterfaces = spec.services
+        .map((service) => {
+        const slotLines = service.members
+            .filter((member) => member.kind === "Slot")
+            .map((member) => {
+            const ret = mapTypeTextToTs(member.payloadTypeText ?? "void");
+            const args = nodeParamArgs(member);
+            return `  ${member.name}(${args}${args.length > 0 ? ", " : ""}timeoutMs?: number): Promise<${ret}>;`;
+        });
+        const signalMembers = service.members
+            .filter((member) => member.kind === "Emitter")
+            .map((member) => {
+            const args = nodeParamArgs(member);
+            return `    ${member.name}(handler: (${args}) => void): () => void;`;
+        });
+        const propertyMembers = service.members
+            .filter((member) => (member.kind === "Input" || member.kind === "Output") && member.payloadTypeText)
+            .map((member) => {
+            const typeText = mapTypeTextToTs(member.payloadTypeText);
+            if (member.kind === "Input") {
+                return `    ${member.name}: {\n      get(): Promise<${typeText}>;\n      on(handler: (value: ${typeText}) => void): () => void;\n    };`;
+            }
+            return `    ${member.name}: {\n      set(value: ${typeText}): void;\n    };`;
+        });
+        return `export interface ${service.name}SessionBridgeService {\n${slotLines.join("\n")}\n  signal: {\n${signalMembers.join("\n")}\n  };\n  property: {\n${propertyMembers.join("\n")}\n  };\n}`;
+    })
+        .join("\n\n");
+    const widgetServiceFields = spec.services.map((service) => `    ${service.name}: ${service.name}SessionBridgeService;`).join("\n");
+    const sessionBridgeFactory = spec.services
+        .map((service) => {
+        const slotMembers = service.members
+            .filter((member) => member.kind === "Slot")
+            .map((member) => {
+            const args = member.parameters.map((p) => p.name).join(", ");
+            const typedArgs = nodeParamArgs(member);
+            return `          ${member.name}: (${typedArgs}${typedArgs.length > 0 ? ", " : ""}timeoutMs = defaultSlotTimeoutMs) => session.${service.name}_${member.name}(${args}${args.length > 0 ? ", " : ""}timeoutMs),`;
+        })
+            .join("\n");
+        const signalMembers = service.members
+            .filter((member) => member.kind === "Emitter")
+            .map((member) => {
+            const args = nodeParamArgs(member);
+            return `            ${member.name}: (handler: (${args}) => void) => session.onSignal("${service.name}", "${member.name}", handler as (...args: unknown[]) => void),`;
+        })
+            .join("\n");
+        const propertyMembers = service.members
+            .filter((member) => (member.kind === "Input" || member.kind === "Output") && member.payloadTypeText)
+            .map((member) => {
+            const typeText = mapTypeTextToTs(member.payloadTypeText);
+            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              set: (value: ${typeText}) => session.set${service.name}_${nodeCap(member.name)}(value)\n            },`;
+        })
+            .join("\n");
+        return `      ${service.name}: {\n${slotMembers}\n        signal: {\n${signalMembers}\n        },\n        property: {\n${propertyMembers}\n        }\n      },`;
+    })
+        .join("\n");
+    const callDispatch = spec.services
+        .flatMap((service) => service.members
+        .filter((member) => member.kind === "Call" && member.payloadTypeText)
+        .map((member) => {
+        return `    if (service === "${service.name}" && member === "${member.name}") {
+      const handler = implementation.${service.name}.${member.name};
+      if (typeof handler !== "function") {
+        const err = new Error("Missing Call handler ${service.name}.${member.name}");
+        emitDiagnostic({
+          code: "HandlerNotRegisteredError",
+          severity: "fatal",
+          category: "bridge",
+          recoverable: false,
+          message: err.message,
+          sessionId: session.id,
+          service,
+          member,
+          requestId
+        });
+        sendJson(session.socket, {
+          type: "callResult",
+          requestId,
+          result: { __anqstError: { code: "HandlerNotRegisteredError", message: err.message, service, member } }
+        });
+        throw err;
+      }
+      Promise.resolve(handler(buildHandlerBridge(session), ...(args as ${nodeParamTuple(member)})))
+        .then((result) => sendJson(session.socket, { type: "callResult", requestId, result }))
+        .catch((error) => {
+          const message = error instanceof Error ? error.message : String(error);
+          emitDiagnostic({
+            code: "CallHandlerError",
+            severity: "error",
+            category: "bridge",
+            recoverable: true,
+            message,
+            sessionId: session.id,
+            service,
+            member,
+            requestId
+          });
+          sendJson(session.socket, {
+            type: "callResult",
+            requestId,
+            result: { __anqstError: { code: "CallHandlerError", message, service, member } }
+          });
+        });
+      return;
+    }`;
+    }))
+        .join("\n");
+    const emitterDispatch = spec.services
+        .flatMap((service) => service.members
+        .filter((member) => member.kind === "Emitter")
+        .map((member) => {
+        return `    if (service === "${service.name}" && member === "${member.name}") {
+      const handler = implementation.${service.name}.${member.name};
+      if (typeof handler !== "function") {
+        const err = new Error("Missing Emitter handler ${service.name}.${member.name}");
+        emitDiagnostic({
+          code: "HandlerNotRegisteredError",
+          severity: "fatal",
+          category: "bridge",
+          recoverable: false,
+          message: err.message,
+          sessionId: session.id,
+          service,
+          member
+        });
+        throw err;
+      }
+      void Promise.resolve(handler(buildHandlerBridge(session), ...(args as ${nodeParamTuple(member)}))).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        emitDiagnostic({
+          code: "EmitterHandlerError",
+          severity: "error",
+          category: "bridge",
+          recoverable: true,
+          message,
+          sessionId: session.id,
+          service,
+          member
+        });
+      });
+      return;
+    }`;
+    }))
+        .join("\n");
+    const inputDispatch = spec.services
+        .flatMap((service) => service.members
+        .filter((member) => member.kind === "Input" && member.payloadTypeText)
+        .map((member) => {
+        return `    if (service === "${service.name}" && member === "${member.name}") {
+      const handler = implementation.${service.name}.${member.name};
+      if (typeof handler !== "function") {
+        const err = new Error("Missing Input handler ${service.name}.${member.name}");
+        emitDiagnostic({
+          code: "HandlerNotRegisteredError",
+          severity: "fatal",
+          category: "bridge",
+          recoverable: false,
+          message: err.message,
+          sessionId: session.id,
+          service,
+          member
+        });
+        throw err;
+      }
+      void Promise.resolve(handler(buildHandlerBridge(session), value as ${mapTypeTextToTs(member.payloadTypeText)})).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        emitDiagnostic({
+          code: "InputHandlerError",
+          severity: "error",
+          category: "bridge",
+          recoverable: true,
+          message,
+          sessionId: session.id,
+          service,
+          member
+        });
+      });
+      return;
+    }`;
+    }))
+        .join("\n");
+    return `import type { Express, Request } from "express";
+import type { WebSocket, WebSocketServer } from "ws";
+${typeImports}
+${typeDecls}
+
+${handlerInterfaces}
+
+export interface ${spec.widgetName}NodeImplementation {
+${implementationFields}
+}
+
+${sessionServiceInterfaces}
+
+export interface ${sessionBridgeTypeName} {
+  ${spec.widgetName}: {
+${widgetServiceFields}
+  };
+}
+
+export interface ${handlerBridgeTypeName} {
+  own: ${sessionBridgeTypeName};
+  others: Record<string, ${sessionBridgeTypeName}>;
+  sessions: Record<string, ${sessionBridgeTypeName}>;
+  sessionId: string;
+}
+
+export interface AnQstDiagnostic {
+  code: string;
+  severity: "info" | "warn" | "error" | "fatal";
+  category: string;
+  recoverable: boolean;
+  message: string;
+  timestamp: string;
+  sessionId?: string;
+  service?: string;
+  member?: string;
+  requestId?: string;
+  context?: Record<string, unknown>;
+}
+
+type SlotPending = {
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+  timeout: ReturnType<typeof setTimeout>;
+};
+
+type QueuedSlotInvocation = {
+  requestId: string;
+  service: string;
+  member: string;
+  args: unknown[];
+  timeoutMs: number;
+  resolve: (value: unknown) => void;
+  reject: (error: Error) => void;
+};
+
+function sendJson(socket: WebSocket, payload: Record<string, unknown>): void {
+  if (socket.readyState === 1) {
+    socket.send(JSON.stringify(payload));
+  }
+}
+
+function makeWsUrl(req: Request, wsPath: string): string {
+  const forwarded = req.header("x-forwarded-proto");
+  const protocol = (forwarded ?? req.protocol).toLowerCase() === "https" ? "wss" : "ws";
+  return \`\${protocol}://\${req.get("host") ?? "localhost"}\${wsPath}\`;
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+class ${spec.widgetName}NodeSession {
+  readonly registeredSlots = new Set<string>();
+  private readonly pending = new Map<string, SlotPending>();
+  private readonly queued = new Map<string, QueuedSlotInvocation[]>();
+  private readonly signalListeners = new Map<string, Set<(...args: unknown[]) => void>>();
+  private readonly inputListeners = new Map<string, Set<(value: unknown) => void>>();
+  private readonly inputState = new Map<string, unknown>();
+  private requestCounter = 0;
+
+  constructor(
+    readonly id: string,
+    readonly socket: WebSocket,
+    private readonly defaultSlotTimeoutMs: number,
+    private readonly maxQueuedPerSlot: number,
+    private readonly emitDiagnostic: (diagnostic: Omit<AnQstDiagnostic, "timestamp">) => void
+  ) {}
+
+  close(reason = "Session closed"): void {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error(reason));
+    }
+    this.pending.clear();
+    for (const queue of this.queued.values()) {
+      for (const item of queue) item.reject(new Error(reason));
+    }
+    this.queued.clear();
+    this.signalListeners.clear();
+    this.inputListeners.clear();
+    this.inputState.clear();
+  }
+
+  registerSlot(service: string, member: string): void {
+    const key = \`\${service}::\${member}\`;
+    this.registeredSlots.add(key);
+    const queue = this.queued.get(key);
+    if (!queue || queue.length === 0) return;
+    this.queued.delete(key);
+    for (const item of queue) this.dispatchSlot(item);
+  }
+
+  resolveSlot(requestId: string, ok: boolean, payload: unknown, error: string): void {
+    const pending = this.pending.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this.pending.delete(requestId);
+    if (ok) {
+      pending.resolve(payload);
+      return;
+    }
+    pending.reject(new Error(error || "Slot invocation failed."));
+  }
+
+  invokeSlot(service: string, member: string, args: unknown[], timeoutMs = this.defaultSlotTimeoutMs): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      const requestId = \`slot-\${this.id}-\${++this.requestCounter}\`;
+      const item: QueuedSlotInvocation = { requestId, service, member, args, timeoutMs, resolve, reject };
+      const key = \`\${service}::\${member}\`;
+      if (!this.registeredSlots.has(key)) {
+        const queue = this.queued.get(key) ?? [];
+        if (queue.length >= this.maxQueuedPerSlot) {
+          const dropped = queue.shift();
+          dropped?.reject(new Error("Slot queue overflow."));
+          this.emitDiagnostic({
+            code: "SlotQueueOverflowError",
+            severity: "warn",
+            category: "bridge",
+            recoverable: true,
+            message: "Slot queue exceeded capacity; oldest queued request dropped.",
+            sessionId: this.id,
+            service,
+            member,
+            context: { maxQueuedPerSlot: this.maxQueuedPerSlot }
+          });
+        }
+        queue.push(item);
+        this.queued.set(key, queue);
+        return;
+      }
+      this.dispatchSlot(item);
+    });
+  }
+
+  setOutputValue(service: string, member: string, value: unknown): void {
+    sendJson(this.socket, { type: "outputUpdated", service, member, value });
+  }
+
+  onSignal(service: string, member: string, handler: (...args: unknown[]) => void): () => void {
+    const key = \`\${service}::\${member}\`;
+    const listeners = this.signalListeners.get(key) ?? new Set<(...args: unknown[]) => void>();
+    listeners.add(handler);
+    this.signalListeners.set(key, listeners);
+    return () => {
+      const existing = this.signalListeners.get(key);
+      if (!existing) return;
+      existing.delete(handler);
+      if (existing.size === 0) this.signalListeners.delete(key);
+    };
+  }
+
+  emitSignal(service: string, member: string, args: unknown[]): void {
+    const key = \`\${service}::\${member}\`;
+    for (const handler of this.signalListeners.get(key) ?? []) {
+      try {
+        handler(...args);
+      } catch {
+        // Listener errors are intentionally isolated from protocol handling.
+      }
+    }
+  }
+
+  onInput(service: string, member: string, handler: (value: unknown) => void): () => void {
+    const key = \`\${service}::\${member}\`;
+    const listeners = this.inputListeners.get(key) ?? new Set<(value: unknown) => void>();
+    listeners.add(handler);
+    this.inputListeners.set(key, listeners);
+    if (this.inputState.has(key)) {
+      handler(this.inputState.get(key));
+    }
+    return () => {
+      const existing = this.inputListeners.get(key);
+      if (!existing) return;
+      existing.delete(handler);
+      if (existing.size === 0) this.inputListeners.delete(key);
+    };
+  }
+
+  setInputState(service: string, member: string, value: unknown): void {
+    const key = \`\${service}::\${member}\`;
+    this.inputState.set(key, value);
+    for (const handler of this.inputListeners.get(key) ?? []) {
+      try {
+        handler(value);
+      } catch {
+        // Listener errors are intentionally isolated from protocol handling.
+      }
+    }
+  }
+
+  readInput(service: string, member: string): Promise<unknown> {
+    const key = \`\${service}::\${member}\`;
+    if (!this.inputState.has(key)) {
+      return Promise.reject(new Error(\`Input value for \${service}.\${member} is unavailable\`));
+    }
+    return Promise.resolve(this.inputState.get(key));
+  }
+
+${slotHelpers}
+${outputHelpers}
+
+  private dispatchSlot(item: QueuedSlotInvocation): void {
+    const timeout = setTimeout(() => {
+      this.pending.delete(item.requestId);
+      item.reject(new Error("slot invocation timeout"));
+      this.emitDiagnostic({
+        code: "BridgeTimeoutError",
+        severity: "error",
+        category: "bridge",
+        recoverable: true,
+        message: "Slot invocation timed out.",
+        sessionId: this.id,
+        service: item.service,
+        member: item.member,
+        requestId: item.requestId
+      });
+    }, item.timeoutMs);
+    this.pending.set(item.requestId, { resolve: item.resolve, reject: item.reject, timeout });
+    sendJson(this.socket, {
+      type: "slotInvocationRequested",
+      requestId: item.requestId,
+      service: item.service,
+      member: item.member,
+      args: item.args
+    });
+  }
+}
+
+export interface ${spec.widgetName}NodeBridgeOptions {
+  app: Express;
+  wsServer: WebSocketServer;
+  implementation: ${spec.widgetName}NodeImplementation;
+  wsPath?: string;
+  wsUrl?: string;
+  devConfigPath?: string;
+  defaultSlotTimeoutMs?: number;
+  maxQueuedSlotInvocationsPerSlot?: number;
+}
+
+export interface ${spec.widgetName}NodeBridge {
+  onSession(listener: (session: ${spec.widgetName}NodeSession) => void): () => void;
+  subscribeDiagnostics(listener: (diagnostic: AnQstDiagnostic) => void): () => void;
+  getSessions(): ReadonlyArray<${spec.widgetName}NodeSession>;
+  getSessionInterfaces(): Record<string, ${sessionBridgeTypeName}>;
+  close(): void;
+}
+
+export function create${spec.widgetName}NodeExpressWsBridge(options: ${spec.widgetName}NodeBridgeOptions): ${spec.widgetName}NodeBridge {
+  const wsPath = options.wsPath ?? "/anqst-bridge";
+  const devConfigPath = options.devConfigPath ?? "/anqst-dev-config.json";
+  const defaultSlotTimeoutMs = options.defaultSlotTimeoutMs ?? 120000;
+  const maxQueuedPerSlot = options.maxQueuedSlotInvocationsPerSlot ?? 1024;
+  const sessions = new Map<WebSocket, ${spec.widgetName}NodeSession>();
+  const diagnosticListeners = new Set<(diagnostic: AnQstDiagnostic) => void>();
+  const sessionListeners = new Set<(session: ${spec.widgetName}NodeSession) => void>();
+  let sessionCounter = 0;
+  const implementation = options.implementation;
+
+  const emitDiagnostic = (diagnostic: Omit<AnQstDiagnostic, "timestamp">): void => {
+    const next: AnQstDiagnostic = { ...diagnostic, timestamp: nowIso() };
+    for (const listener of diagnosticListeners) listener(next);
+  };
+
+  const getSessionInterfaces = (): Record<string, ${sessionBridgeTypeName}> => {
+    const out: Record<string, ${sessionBridgeTypeName}> = {};
+    for (const session of sessions.values()) {
+      out[session.id] = {
+        ${spec.widgetName}: {
+${sessionBridgeFactory}
+        }
+      };
+    }
+    return out;
+  };
+
+  const buildHandlerBridge = (session: ${spec.widgetName}NodeSession): ${handlerBridgeTypeName} => {
+    const byId = getSessionInterfaces();
+    const others: Record<string, ${sessionBridgeTypeName}> = {};
+    for (const [id, view] of Object.entries(byId)) {
+      if (id === session.id) continue;
+      others[id] = view;
+    }
+    return {
+      own: byId[session.id],
+      others,
+      sessions: byId,
+      sessionId: session.id
+    };
+  };
+
+  options.app.get(devConfigPath, (req, res) => {
+    res.json({
+      wsUrl: options.wsUrl ?? makeWsUrl(req, wsPath),
+      bridgeObject: "${spec.widgetName}Bridge"
+    });
+  });
+
+  const handleMessage = (session: ${spec.widgetName}NodeSession, raw: string): void => {
+    let message: Record<string, unknown>;
+    try {
+      message = JSON.parse(raw) as Record<string, unknown>;
+    } catch {
+      emitDiagnostic({
+        code: "DeserializationError",
+        severity: "warn",
+        category: "bridge",
+        recoverable: true,
+        message: "Incoming WS payload is not valid JSON.",
+        sessionId: session.id
+      });
+      return;
+    }
+    const type = String(message.type ?? "");
+    if (type === "registerSlot") {
+      session.registerSlot(String(message.service ?? ""), String(message.member ?? ""));
+      return;
+    }
+    if (type === "resolveSlot") {
+      session.resolveSlot(String(message.requestId ?? ""), Boolean(message.ok), message.payload, String(message.error ?? ""));
+      return;
+    }
+    if (type === "call") {
+      const service = String(message.service ?? "");
+      const member = String(message.member ?? "");
+      const requestId = String(message.requestId ?? "");
+      const args = Array.isArray(message.args) ? (message.args as unknown[]) : [];
+${callDispatch}
+      const err = new Error(\`No Call mapping found for \${service}.\${member}\`);
+      emitDiagnostic({
+        code: "HandlerNotRegisteredError",
+        severity: "fatal",
+        category: "bridge",
+        recoverable: false,
+        message: err.message,
+        sessionId: session.id,
+        service,
+        member,
+        requestId
+      });
+      sendJson(session.socket, {
+        type: "callResult",
+        requestId,
+        result: { __anqstError: { code: "HandlerNotRegisteredError", message: err.message, service, member } }
+      });
+      throw err;
+    }
+    if (type === "emit") {
+      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({
+        code: "HandlerNotRegisteredError",
+        severity: "fatal",
+        category: "bridge",
+        recoverable: false,
+        message: err.message,
+        sessionId: session.id,
+        service,
+        member
+      });
+      throw err;
+    }
+    if (type === "setInput") {
+      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({
+        code: "HandlerNotRegisteredError",
+        severity: "fatal",
+        category: "bridge",
+        recoverable: false,
+        message: err.message,
+        sessionId: session.id,
+        service,
+        member
+      });
+      throw err;
+    }
+    emitDiagnostic({
+      code: "ProtocolMessageUnknown",
+      severity: "warn",
+      category: "bridge",
+      recoverable: true,
+      message: \`Unknown WS message type '\${type}'.\`,
+      sessionId: session.id
+    });
+  };
+
+  const onConnection = (socket: WebSocket): void => {
+    const session = new ${spec.widgetName}NodeSession(
+      \`session-\${++sessionCounter}\`,
+      socket,
+      defaultSlotTimeoutMs,
+      maxQueuedPerSlot,
+      emitDiagnostic
+    );
+    sessions.set(socket, session);
+    for (const listener of sessionListeners) listener(session);
+    sendJson(socket, { type: "hostReady" });
+    socket.on("message", (data) => {
+      handleMessage(session, typeof data === "string" ? data : data.toString());
+    });
+    socket.on("close", () => {
+      session.close("Session closed");
+      sessions.delete(socket);
+    });
+  };
+
+  options.wsServer.on("connection", onConnection);
+
+  return {
+    onSession(listener) {
+      sessionListeners.add(listener);
+      for (const session of sessions.values()) listener(session);
+      return () => sessionListeners.delete(listener);
+    },
+    subscribeDiagnostics(listener) {
+      diagnosticListeners.add(listener);
+      return () => diagnosticListeners.delete(listener);
+    },
+    getSessions() {
+      return [...sessions.values()];
+    },
+    getSessionInterfaces() {
+      return getSessionInterfaces();
+    },
+    close() {
+      options.wsServer.off("connection", onConnection);
+      for (const session of sessions.values()) session.close("Bridge closed");
+      sessions.clear();
+    }
+  };
+}
+`;
+}
+function renderTypeRootIndexDts(spec) {
+    const indexDecls = renderTypeIndexDts().trim();
+    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` : "";
+}
+function generatedCppLibraryDirName(widgetName) {
+    return `${widgetName}_QtWidget`;
+}
+function generatedNodeExpressWsDirName(widgetName) {
+    return `${widgetName}_node_express_ws`;
+}
+function generateOutputs(spec, options = { emitQWidget: true, emitAngularService: true, emitNodeExpressWs: false }) {
+    const cppDir = generatedCppLibraryDirName(spec.widgetName);
+    const nodeDir = generatedNodeExpressWsDirName(spec.widgetName);
+    const outputs = {};
+    if (options.emitAngularService) {
+        outputs["npmpackage/package.json"] = renderNpmPackage(spec);
+        outputs["npmpackage/index.ts"] = renderTsIndex();
+        outputs["npmpackage/services.ts"] = renderTsServices(spec);
+        outputs["npmpackage/types.ts"] = renderTsTypes(spec);
+        outputs["npmpackage/index.js"] = renderJsIndex();
+        outputs["npmpackage/services.js"] = renderJsServices();
+        outputs["npmpackage/types.js"] = renderJsTypes();
+        outputs["npmpackage/types/index.d.ts"] = renderTypeRootIndexDts(spec);
+        outputs["npmpackage/types/services.d.ts"] = renderTypeServicesDts(spec);
+        outputs["npmpackage/types/types.d.ts"] = renderTypeTypesDts(spec);
+    }
+    if (options.emitQWidget) {
+        const cppTypes = buildCppTypeContext(spec);
+        outputs[`${cppDir}/CMakeLists.txt`] = renderCMake(spec);
+        outputs[`${cppDir}/${spec.widgetName}.qrc`] = renderEmbeddedQrc(spec.widgetName, []);
+        outputs[`${cppDir}/include/${spec.widgetName}.h`] = renderWidgetHeader(spec, cppTypes);
+        outputs[`${cppDir}/include/${spec.widgetName}Types.h`] = renderTypesHeader(spec, cppTypes);
+        outputs[`${cppDir}/${spec.widgetName}.cpp`] = renderCppStub(spec, cppTypes);
+    }
+    if (options.emitNodeExpressWs) {
+        outputs[`${nodeDir}/package.json`] = renderNodeExpressWsPackage(spec);
+        outputs[`${nodeDir}/index.ts`] = renderNodeExpressWsIndex(spec);
+        outputs[`${nodeDir}/types/index.d.ts`] = renderNodeExpressWsTypes(spec);
+    }
+    return outputs;
+}
+function writeGeneratedOutputs(cwd, outputs) {
+    const outputRoot = node_path_1.default.join(cwd, "generated_output");
+    for (const [relPath, content] of Object.entries(outputs)) {
+        const filePath = node_path_1.default.join(outputRoot, relPath);
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
+        node_fs_1.default.writeFileSync(filePath, content, "utf8");
+    }
+}
+function installTypeScriptOutputs(cwd) {
+    const sourceDir = node_path_1.default.join(cwd, "generated_output", "npmpackage");
+    const targetDir = node_path_1.default.join(cwd, "src", "anqst-generated");
+    if (!node_fs_1.default.existsSync(sourceDir))
+        return;
+    node_fs_1.default.rmSync(targetDir, { recursive: true, force: true });
+    node_fs_1.default.mkdirSync(targetDir, { recursive: true });
+    const queue = [sourceDir];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const entry of node_fs_1.default.readdirSync(current, { withFileTypes: true })) {
+            const abs = node_path_1.default.join(current, entry.name);
+            const rel = node_path_1.default.relative(sourceDir, abs);
+            const dst = node_path_1.default.join(targetDir, rel);
+            if (entry.isDirectory()) {
+                node_fs_1.default.mkdirSync(dst, { recursive: true });
+                queue.push(abs);
+            }
+            else if (entry.isFile()) {
+                node_fs_1.default.mkdirSync(node_path_1.default.dirname(dst), { recursive: true });
+                node_fs_1.default.copyFileSync(abs, dst);
+            }
+        }
+    }
+}
+function listFilesRecursively(rootDir) {
+    const output = [];
+    const queue = [rootDir];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const entries = node_fs_1.default.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            const abs = node_path_1.default.join(current, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(abs);
+                continue;
+            }
+            if (entry.isFile()) {
+                output.push(normalizeSlashes(node_path_1.default.relative(rootDir, abs)));
+            }
+        }
+    }
+    return output.sort();
+}
+function copyDirectoryRecursive(sourceDir, targetDir) {
+    const queue = [sourceDir];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const entries = node_fs_1.default.readdirSync(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const sourceAbs = node_path_1.default.join(current, entry.name);
+            const rel = node_path_1.default.relative(sourceDir, sourceAbs);
+            const targetAbs = node_path_1.default.join(targetDir, rel);
+            if (entry.isDirectory()) {
+                node_fs_1.default.mkdirSync(targetAbs, { recursive: true });
+                queue.push(sourceAbs);
+                continue;
+            }
+            if (entry.isFile()) {
+                node_fs_1.default.mkdirSync(node_path_1.default.dirname(targetAbs), { recursive: true });
+                node_fs_1.default.copyFileSync(sourceAbs, targetAbs);
+            }
+        }
+    }
+}
+function resolveDistWebRoot(cwd) {
+    const distDir = node_path_1.default.join(cwd, "dist");
+    if (!node_fs_1.default.existsSync(distDir)) {
+        return null;
+    }
+    const candidates = [];
+    const angularJsonPath = node_path_1.default.join(cwd, "angular.json");
+    if (node_fs_1.default.existsSync(angularJsonPath)) {
+        try {
+            const angularJson = JSON.parse(node_fs_1.default.readFileSync(angularJsonPath, "utf8"));
+            const projectNames = Object.keys(angularJson.projects ?? {});
+            const orderedProjects = [];
+            if (typeof angularJson.defaultProject === "string" && angularJson.defaultProject.length > 0) {
+                orderedProjects.push(angularJson.defaultProject);
+            }
+            for (const projectName of projectNames) {
+                if (!orderedProjects.includes(projectName)) {
+                    orderedProjects.push(projectName);
+                }
+            }
+            for (const projectName of orderedProjects) {
+                const outputPathValue = angularJson.projects?.[projectName]?.architect?.build?.options?.outputPath;
+                if (typeof outputPathValue === "string" && outputPathValue.length > 0) {
+                    const absolute = node_path_1.default.resolve(cwd, outputPathValue);
+                    candidates.push(node_path_1.default.join(absolute, "browser"));
+                    candidates.push(absolute);
+                    continue;
+                }
+                if (outputPathValue &&
+                    typeof outputPathValue === "object" &&
+                    typeof outputPathValue.base === "string" &&
+                    outputPathValue.base.length > 0) {
+                    const absolute = node_path_1.default.resolve(cwd, outputPathValue.base);
+                    candidates.push(node_path_1.default.join(absolute, "browser"));
+                    candidates.push(absolute);
+                    continue;
+                }
+                candidates.push(node_path_1.default.join(distDir, projectName, "browser"));
+                candidates.push(node_path_1.default.join(distDir, projectName));
+            }
+        }
+        catch {
+            // Best-effort: fallback candidates below.
+        }
+    }
+    const seen = new Set();
+    const dedupedCandidates = candidates.filter((candidate) => {
+        if (seen.has(candidate))
+            return false;
+        seen.add(candidate);
+        return true;
+    });
+    for (const candidate of dedupedCandidates) {
+        if (node_fs_1.default.existsSync(node_path_1.default.join(candidate, "index.html"))) {
+            return candidate;
+        }
+    }
+    const discovered = [];
+    const walk = (dir, depth) => {
+        if (depth > 6)
+            return;
+        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            const abs = node_path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(abs, depth + 1);
+                continue;
+            }
+            if (entry.isFile() && entry.name === "index.html") {
+                discovered.push(dir);
+            }
+        }
+    };
+    walk(distDir, 0);
+    if (discovered.length === 0) {
+        return null;
+    }
+    discovered.sort((a, b) => {
+        const aBrowser = normalizeSlashes(a).includes("/browser") ? 0 : 1;
+        const bBrowser = normalizeSlashes(b).includes("/browser") ? 0 : 1;
+        if (aBrowser !== bBrowser)
+            return aBrowser - bBrowser;
+        return a.length - b.length;
+    });
+    return discovered[0];
+}
+function installEmbeddedWebBundle(cwd, widgetName) {
+    const distWebRoot = resolveDistWebRoot(cwd);
+    if (distWebRoot === null) {
+        return false;
+    }
+    if (!node_fs_1.default.existsSync(node_path_1.default.join(distWebRoot, "index.html"))) {
+        return false;
+    }
+    const cppLibraryRoot = node_path_1.default.join(cwd, "generated_output", generatedCppLibraryDirName(widgetName));
+    const cppLibraryWebRoot = node_path_1.default.join(cppLibraryRoot, "webapp");
+    node_fs_1.default.rmSync(cppLibraryWebRoot, { recursive: true, force: true });
+    node_fs_1.default.mkdirSync(cppLibraryWebRoot, { recursive: true });
+    copyDirectoryRecursive(distWebRoot, cppLibraryWebRoot);
+    normalizeEmbeddedIndexHtml(node_path_1.default.join(cppLibraryWebRoot, "index.html"), cppLibraryWebRoot);
+    const embeddedFiles = listFilesRecursively(cppLibraryWebRoot);
+    const qrcPath = node_path_1.default.join(cppLibraryRoot, `${widgetName}.qrc`);
+    node_fs_1.default.writeFileSync(qrcPath, renderEmbeddedQrc(widgetName, embeddedFiles), "utf8");
+    return true;
+}
+function normalizeEmbeddedIndexHtml(indexPath, webRoot) {
+    if (!node_fs_1.default.existsSync(indexPath)) {
+        return;
+    }
+    let html = node_fs_1.default.readFileSync(indexPath, "utf8");
+    if (html.includes('<base href="/">')) {
+        html = html.replace('<base href="/">', '<base href="./">');
+    }
+    html = html.replace(/<link\b[^>]*href="([^"]+\.css)"[^>]*>\s*/g, (full, href) => {
+        const absolute = node_path_1.default.join(webRoot, href);
+        if (!node_fs_1.default.existsSync(absolute)) {
+            return "";
+        }
+        if (node_fs_1.default.statSync(absolute).size === 0) {
+            return "";
+        }
+        return full;
+    });
+    node_fs_1.default.writeFileSync(indexPath, html, "utf8");
+}
+function renderQtIntegrationCMake(widgetName) {
+    const generatedRootVar = "ANQST_GENERATED_CPP_DIR";
+    const generatedIncludeVar = "ANQST_GENERATED_INCLUDE_DIR";
+    const webappRootVar = "ANQST_WEBAPP_ROOT";
+    const widgetTarget = `${widgetName}Widget`;
+    const autogenTarget = `${widgetTarget}_anqst_codegen`;
+    return `cmake_minimum_required(VERSION 3.21)
+
+set(${webappRootVar} "\${CMAKE_CURRENT_LIST_DIR}/..")
+set(${generatedRootVar} "\${${webappRootVar}}/generated_output/${generatedCppLibraryDirName(widgetName)}")
+set(${generatedIncludeVar} "\${${generatedRootVar}}/include")
+
+if(TARGET ${widgetTarget})
+    return()
+endif()
+
+if(NOT TARGET anqstwebhostbase)
+    message(FATAL_ERROR "Target 'anqstwebhostbase' must exist before including 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)
+
+add_custom_command(
+    OUTPUT
+        "\${${generatedRootVar}}/CMakeLists.txt"
+        "\${${generatedRootVar}}/${widgetName}.qrc"
+        "\${${generatedRootVar}}/${widgetName}.cpp"
+        "\${${generatedIncludeVar}}/${widgetName}.h"
+        "\${${generatedIncludeVar}}/${widgetName}Types.h"
+        "\${${generatedRootVar}}/webapp/index.html"
+    COMMAND "\${ANQST_NPM_EXECUTABLE}" install
+    COMMAND "\${ANQST_NPM_EXECUTABLE}" run anqst:build
+    WORKING_DIRECTORY "\${${webappRootVar}}"
+    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}Types.h"
+        "\${${generatedRootVar}}/webapp/index.html"
+)
+
+set_source_files_properties(
+    "\${${generatedRootVar}}/${widgetName}.qrc"
+    "\${${generatedRootVar}}/${widgetName}.cpp"
+    "\${${generatedIncludeVar}}/${widgetName}.h"
+    "\${${generatedIncludeVar}}/${widgetName}Types.h"
+    PROPERTIES GENERATED TRUE
+)
+
+add_library(${widgetTarget}
+    "\${${generatedRootVar}}/${widgetName}.qrc"
+    "\${${generatedRootVar}}/${widgetName}.cpp"
+    "\${${generatedIncludeVar}}/${widgetName}.h"
+    "\${${generatedIncludeVar}}/${widgetName}Types.h"
+)
+add_dependencies(${widgetTarget} ${autogenTarget})
+target_include_directories(${widgetTarget}
+    PUBLIC
+        "\${${generatedIncludeVar}}"
+)
+target_link_libraries(${widgetTarget}
+    PUBLIC
+        anqstwebhostbase
+)
+`;
+}
+function installQtIntegrationCMake(cwd, widgetName) {
+    const integrationDir = node_path_1.default.join(cwd, "anqst-cmake");
+    node_fs_1.default.mkdirSync(integrationDir, { recursive: true });
+    node_fs_1.default.writeFileSync(node_path_1.default.join(integrationDir, "CMakeLists.txt"), renderQtIntegrationCMake(widgetName), "utf8");
+}