@dusted/anqst 0.1.0 → 0.1.2

package/dist/src/emit.js

@@ -5,12 +5,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateOutputs = generateOutputs;
 exports.writeGeneratedOutputs = writeGeneratedOutputs;
-exports.installTypeScriptOutputs = installTypeScriptOutputs;
 exports.installEmbeddedWebBundle = installEmbeddedWebBundle;
 exports.installQtIntegrationCMake = installQtIntegrationCMake;
+exports.installQtDesignerPluginCMake = installQtDesignerPluginCMake;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const typescript_1 = __importDefault(require("typescript"));
+const pngjs_1 = require("pngjs");
+const layout_1 = require("./layout");
 function stripAnQstType(typeText) {
     return typeText
         .replace(/\bAnQst\.Type\.stringArray\b/g, "string[]")
@@ -158,6 +160,87 @@ function cppToVariantExpression(cppType, expr) {
     }
     return `QVariant::fromValue(${expr})`;
 }
+function splitTopLevelTemplateArgs(text) {
+    const args = [];
+    let start = 0;
+    let depth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === "<") {
+            depth++;
+            continue;
+        }
+        if (ch === ">") {
+            depth--;
+            continue;
+        }
+        if (ch === "," && depth === 0) {
+            args.push(text.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    const tail = text.slice(start).trim();
+    if (tail.length > 0) {
+        args.push(tail);
+    }
+    return args;
+}
+function templateTypeArgs(cppType, containerName) {
+    const trimmed = cppType.trim();
+    const prefix = `${containerName}<`;
+    if (!trimmed.startsWith(prefix) || !trimmed.endsWith(">")) {
+        return null;
+    }
+    const inner = trimmed.slice(prefix.length, -1).trim();
+    if (inner.length === 0)
+        return [];
+    return splitTopLevelTemplateArgs(inner);
+}
+function isNumericCppType(cppType) {
+    return [
+        "double",
+        "qint64",
+        "quint64",
+        "qint32",
+        "quint32",
+        "qint16",
+        "quint16",
+        "qint8",
+        "quint8",
+        "int8_t",
+        "uint8_t",
+        "int16_t",
+        "uint16_t",
+        "int32_t",
+        "uint32_t"
+    ].includes(cppType);
+}
+function designerPlaceholderCppExpression(cppType, memberName) {
+    const escapedMember = escapeCppStringLiteral(memberName);
+    const stringLiteral = `QStringLiteral("${escapedMember} value")`;
+    if (cppType === "QString")
+        return stringLiteral;
+    if (cppType === "bool")
+        return "true";
+    if (isNumericCppType(cppType))
+        return `static_cast<${cppType}>(1)`;
+    if (cppType === "QStringList")
+        return `QStringList{${stringLiteral}}`;
+    if (cppType === "QVariantMap") {
+        return `QVariantMap{{QStringLiteral("${escapedMember}"), QVariant(${stringLiteral})}}`;
+    }
+    const optionalArgs = templateTypeArgs(cppType, "std::optional");
+    if (optionalArgs && optionalArgs.length === 1) {
+        const inner = optionalArgs[0];
+        return `std::optional<${inner}>{${designerPlaceholderCppExpression(inner, memberName)}}`;
+    }
+    const listArgs = templateTypeArgs(cppType, "QList");
+    if (listArgs && listArgs.length === 1) {
+        const inner = listArgs[0];
+        return `QList<${inner}>{${designerPlaceholderCppExpression(inner, memberName)}}`;
+    }
+    return `${cppType}{}`;
+}
 function collectStructDecls(spec) {
     const out = new Map();
     for (const d of spec.namespaceTypeDecls)
@@ -266,7 +349,7 @@ function normalizeImportPathForGenerated(specFilePath, generatedFileRelPath, mod
         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 generatedAbs = node_path_1.default.resolve(node_path_1.default.dirname(specFilePath), "generated", 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);
@@ -746,7 +829,12 @@ function renderCppStub(spec, cppTypes) {
             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();`);
+            lines.push(`        if (!m_${member.name}Handler) {`);
+            lines.push(`            if (property("anqstDesignerContext").toBool()) {`);
+            lines.push(`                return ${cppToVariantExpression(cppType, designerPlaceholderCppExpression(cppType, member.name))};`);
+            lines.push(`            }`);
+            lines.push(`            return QVariant();`);
+            lines.push(`        }`);
             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]);
@@ -913,6 +1001,57 @@ function escapeXml(text) {
 function normalizeSlashes(value) {
     return value.split(node_path_1.default.sep).join("/");
 }
+function resolveActiveBuildStamp() {
+    const fromEnv = process.env.ANQST_BUILD_STAMP?.trim();
+    if (fromEnv && fromEnv.length > 0) {
+        return fromEnv;
+    }
+    const activePath = node_path_1.default.resolve(__dirname, "..", "..", ".anqstgen-version-active.json");
+    if (!node_fs_1.default.existsSync(activePath)) {
+        return "";
+    }
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(activePath, "utf8"));
+        if (typeof parsed.active === "string" && parsed.active.trim().length > 0) {
+            return parsed.active.trim();
+        }
+    }
+    catch {
+        return "";
+    }
+    return "";
+}
+function withBuildStamp(relativePath, content) {
+    const stamp = resolveActiveBuildStamp();
+    if (!stamp) {
+        return content;
+    }
+    const marker = `Built by AnQst ${stamp}`;
+    const rel = normalizeSlashes(relativePath);
+    const lower = rel.toLowerCase();
+    if (lower.endsWith(".json")) {
+        try {
+            const parsed = JSON.parse(content);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                const next = { "//": marker, ...parsed };
+                return `${JSON.stringify(next, null, 2)}\n`;
+            }
+        }
+        catch {
+            // If JSON parsing fails, fall through to plain comment prefix.
+        }
+    }
+    if (lower.endsWith(".qrc") || lower.endsWith(".xml") || lower.endsWith(".html")) {
+        return `<!-- ${marker} -->\n${content}`;
+    }
+    if (lower.endsWith(".cmake")) {
+        return `# ${marker}\n${content}`;
+    }
+    if (lower.endsWith(".h") || lower.endsWith(".cpp") || lower.endsWith(".ts") || lower.endsWith(".js") || lower.endsWith(".d.ts")) {
+        return `// ${marker}\n${content}`;
+    }
+    return `# ${marker}\n${content}`;
+}
 function renderEmbeddedQrc(widgetName, embeddedWebFiles) {
     const files = [...embeddedWebFiles].sort();
     const lines = [];
@@ -1087,7 +1226,7 @@ export declare class ${serviceName} {
 }
 function renderTsServices(spec) {
     const serviceClasses = spec.services.map((s) => renderTsService(spec, s.name)).join("\n");
-    const externalTypeImports = renderRequiredTypeImports(spec, "npmpackage/services.ts").trim();
+    const externalTypeImports = renderRequiredTypeImports(spec, `frontend/${(0, layout_1.generatedFrontendDirName)(spec.widgetName)}/services.ts`).trim();
     const localTypeImports = renderLocalTypeImports(spec).trim();
     const typeImports = [externalTypeImports, localTypeImports].filter((s) => s.length > 0).join("\n");
     const typeImportsBlock = typeImports.length > 0 ? `${typeImports}\n\n` : "";
@@ -1231,6 +1370,11 @@ class WebSocketBridgeAdapter implements BridgeAdapter {
       }
       if (type === "hostError") {
         console.error("AnQst host error:", message["payload"]);
+        return;
+      }
+      if (type === "widgetReattached") {
+        document.body.textContent = "Widget Reattached";
+        this.socket.close();
       }
     });
   }
@@ -1240,12 +1384,22 @@ class WebSocketBridgeAdapter implements BridgeAdapter {
     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.");
+    const config = (await configResponse.json()) as { wsUrl?: string; wsPath?: string };
+    let wsUrl = config.wsUrl;
+    if (!wsUrl && config.wsPath) {
+      const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+      wsUrl = protocol + "//" + window.location.host + config.wsPath;
+    }
+    if (!wsUrl) {
+      throw new Error("AnQst host bootstrap missing: wsUrl/wsPath is unavailable.");
+    }
+    if (wsUrl.startsWith("http://")) {
+      wsUrl = "ws://" + wsUrl.slice("http://".length);
+    } else if (wsUrl.startsWith("https://")) {
+      wsUrl = "wss://" + wsUrl.slice("https://".length);
     }
     return await new Promise<WebSocketBridgeAdapter>((resolve, reject) => {
-      const socket = new WebSocket(config.wsUrl!);
+      const socket = new WebSocket(wsUrl!);
       socket.addEventListener("open", () => resolve(new WebSocketBridgeAdapter(socket)));
       socket.addEventListener("error", () => reject(new Error("Failed to connect to AnQst WebSocket bridge.")));
     });
@@ -1397,13 +1551,13 @@ ${serviceClasses}
 `;
 }
 function renderTsTypes(spec) {
-    const typeImports = renderRequiredTypeImports(spec, "npmpackage/types.ts").trim();
+    const typeImports = renderRequiredTypeImports(spec, `frontend/${(0, layout_1.generatedFrontendDirName)(spec.widgetName)}/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 externalTypeImports = renderRequiredTypeImports(spec, `frontend/${(0, layout_1.generatedFrontendDirName)(spec.widgetName)}/types/services.d.ts`).trim();
     const localTypeImports = renderLocalTypeImports(spec).trim();
     const serviceDecls = spec.services
         .map((s) => renderTsServiceDts(spec, s.name))
@@ -1412,7 +1566,7 @@ function renderTypeServicesDts(spec) {
     return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
 }
 function renderTypeTypesDts(spec) {
-    const typeImports = renderRequiredTypeImports(spec, "npmpackage/types/types.d.ts").trim();
+    const typeImports = renderRequiredTypeImports(spec, `frontend/${(0, layout_1.generatedFrontendDirName)(spec.widgetName)}/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` : "";
@@ -1478,13 +1632,13 @@ 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 typeImports = renderRequiredTypeImports(spec, `backend/node/express/${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 typeImports = renderRequiredTypeImports(spec, `backend/node/express/${generatedNodeExpressWsDirName(spec.widgetName)}/index.ts`);
     const typeDecls = renderTypeDeclarations(spec, true);
     const handlerBridgeTypeName = `${spec.widgetName}HandlerBridge`;
     const sessionBridgeTypeName = `${spec.widgetName}SessionBridge`;
@@ -2183,26 +2337,27 @@ function renderTypeRootIndexDts(spec) {
     return sections.length > 0 ? `${sections.join("\n\n")}\n` : "";
 }
 function generatedCppLibraryDirName(widgetName) {
-    return `${widgetName}_QtWidget`;
+    return (0, layout_1.generatedQtWidgetDirName)(widgetName);
 }
 function generatedNodeExpressWsDirName(widgetName) {
-    return `${widgetName}_node_express_ws`;
+    return (0, layout_1.generatedNodeExpressDirName)(widgetName);
 }
 function generateOutputs(spec, options = { emitQWidget: true, emitAngularService: true, emitNodeExpressWs: false }) {
-    const cppDir = generatedCppLibraryDirName(spec.widgetName);
-    const nodeDir = generatedNodeExpressWsDirName(spec.widgetName);
+    const frontendDir = `frontend/${(0, layout_1.generatedFrontendDirName)(spec.widgetName)}`;
+    const cppDir = `backend/cpp/qt/${generatedCppLibraryDirName(spec.widgetName)}`;
+    const nodeDir = `backend/node/express/${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);
+        outputs[`${frontendDir}/package.json`] = renderNpmPackage(spec);
+        outputs[`${frontendDir}/index.ts`] = renderTsIndex();
+        outputs[`${frontendDir}/services.ts`] = renderTsServices(spec);
+        outputs[`${frontendDir}/types.ts`] = renderTsTypes(spec);
+        outputs[`${frontendDir}/index.js`] = renderJsIndex();
+        outputs[`${frontendDir}/services.js`] = renderJsServices();
+        outputs[`${frontendDir}/types.js`] = renderJsTypes();
+        outputs[`${frontendDir}/types/index.d.ts`] = renderTypeRootIndexDts(spec);
+        outputs[`${frontendDir}/types/services.d.ts`] = renderTypeServicesDts(spec);
+        outputs[`${frontendDir}/types/types.d.ts`] = renderTypeTypesDts(spec);
     }
     if (options.emitQWidget) {
         const cppTypes = buildCppTypeContext(spec);
@@ -2220,36 +2375,11 @@ function generateOutputs(spec, options = { emitQWidget: true, emitAngularService
     return outputs;
 }
 function writeGeneratedOutputs(cwd, outputs) {
-    const outputRoot = node_path_1.default.join(cwd, "generated_output");
+    const outputRoot = (0, layout_1.anqstGeneratedRootDir)(cwd);
     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);
-            }
-        }
+        node_fs_1.default.writeFileSync(filePath, withBuildStamp(relPath, content), "utf8");
     }
 }
 function listFilesRecursively(rootDir) {
@@ -2385,7 +2515,7 @@ function installEmbeddedWebBundle(cwd, widgetName) {
     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 cppLibraryRoot = (0, layout_1.resolveGeneratedLayoutPaths)(cwd, widgetName).cppQtWidgetRoot;
     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 });
@@ -2393,7 +2523,7 @@ function installEmbeddedWebBundle(cwd, widgetName) {
     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");
+    node_fs_1.default.writeFileSync(qrcPath, withBuildStamp(`${widgetName}.qrc`, renderEmbeddedQrc(widgetName, embeddedFiles)), "utf8");
     return true;
 }
 function normalizeEmbeddedIndexHtml(indexPath, webRoot) {
@@ -2417,15 +2547,15 @@ function normalizeEmbeddedIndexHtml(indexPath, webRoot) {
     node_fs_1.default.writeFileSync(indexPath, html, "utf8");
 }
 function renderQtIntegrationCMake(widgetName) {
-    const generatedRootVar = "ANQST_GENERATED_CPP_DIR";
+    const generatedRootVar = "ANQST_GENERATED_WIDGET_DIR";
     const generatedIncludeVar = "ANQST_GENERATED_INCLUDE_DIR";
-    const webappRootVar = "ANQST_WEBAPP_ROOT";
+    const projectRootVar = "ANQST_PROJECT_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(${projectRootVar} "\${CMAKE_CURRENT_LIST_DIR}/../../../../..")
+set(${generatedRootVar} "\${CMAKE_CURRENT_LIST_DIR}/../qt/${generatedCppLibraryDirName(widgetName)}")
 set(${generatedIncludeVar} "\${${generatedRootVar}}/include")
 
 if(TARGET ${widgetTarget})
@@ -2433,7 +2563,7 @@ if(TARGET ${widgetTarget})
 endif()
 
 if(NOT TARGET anqstwebhostbase)
-    message(FATAL_ERROR "Target 'anqstwebhostbase' must exist before including anqst-cmake for ${widgetName}.")
+    message(FATAL_ERROR "Target 'anqstwebhostbase' must exist before including generated AnQst CMake for ${widgetName}.")
 endif()
 
 find_package(Qt5 REQUIRED COMPONENTS Core Widgets)
@@ -2453,7 +2583,7 @@ add_custom_command(
         "\${${generatedRootVar}}/webapp/index.html"
     COMMAND "\${ANQST_NPM_EXECUTABLE}" install
     COMMAND "\${ANQST_NPM_EXECUTABLE}" run anqst:build
-    WORKING_DIRECTORY "\${${webappRootVar}}"
+    WORKING_DIRECTORY "\${${projectRootVar}}"
     COMMENT "Generating AnQst widget library (${widgetTarget}) from Angular project"
     VERBATIM
 )
@@ -2494,7 +2624,301 @@ target_link_libraries(${widgetTarget}
 `;
 }
 function installQtIntegrationCMake(cwd, widgetName) {
-    const integrationDir = node_path_1.default.join(cwd, "anqst-cmake");
+    const integrationDir = (0, layout_1.resolveGeneratedLayoutPaths)(cwd, widgetName).cppCmakeRoot;
     node_fs_1.default.mkdirSync(integrationDir, { recursive: true });
-    node_fs_1.default.writeFileSync(node_path_1.default.join(integrationDir, "CMakeLists.txt"), renderQtIntegrationCMake(widgetName), "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(integrationDir, "CMakeLists.txt"), withBuildStamp("backend/cpp/cmake/CMakeLists.txt", renderQtIntegrationCMake(widgetName)), "utf8");
+}
+function normalizeIcoSize(dim) {
+    return dim === 0 ? 256 : dim;
+}
+function escapeCppStringLiteral(value) {
+    return value
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\r/g, "\\r")
+        .replace(/\n/g, "\\n");
+}
+function readDistFavicon(cwd) {
+    const distRoot = node_path_1.default.join(cwd, "dist");
+    if (!node_fs_1.default.existsSync(distRoot) || !node_fs_1.default.statSync(distRoot).isDirectory()) {
+        return null;
+    }
+    const stack = [distRoot];
+    while (stack.length > 0) {
+        const current = stack.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 fullPath = node_path_1.default.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            if (entry.isFile() && entry.name.toLowerCase() === "favicon.ico") {
+                return node_fs_1.default.readFileSync(fullPath);
+            }
+        }
+    }
+    return null;
+}
+function resolveFaviconIcoBuffer(cwd) {
+    const distFavicon = readDistFavicon(cwd);
+    if (distFavicon !== null) {
+        return distFavicon;
+    }
+    const fallbackFiles = [
+        node_path_1.default.join(cwd, "res", "favicon.ico"),
+        node_path_1.default.join(cwd, "src", "favicon.ico"),
+        node_path_1.default.join(cwd, "favicon.ico")
+    ];
+    for (const filePath of fallbackFiles) {
+        if (node_fs_1.default.existsSync(filePath) && node_fs_1.default.statSync(filePath).isFile()) {
+            return node_fs_1.default.readFileSync(filePath);
+        }
+    }
+    return null;
+}
+function decodeIcoBmpToPng(imageData) {
+    if (imageData.length < 40) {
+        throw new Error("ICO BMP frame too small.");
+    }
+    const headerSize = imageData.readUInt32LE(0);
+    if (headerSize < 40 || imageData.length < headerSize) {
+        throw new Error("ICO BMP frame has unsupported DIB header.");
+    }
+    const width = imageData.readInt32LE(4);
+    const heightTotal = imageData.readInt32LE(8);
+    const planes = imageData.readUInt16LE(12);
+    const bitCount = imageData.readUInt16LE(14);
+    const compression = imageData.readUInt32LE(16);
+    if (width <= 0 || heightTotal <= 0) {
+        throw new Error("ICO BMP frame has invalid dimensions.");
+    }
+    const height = Math.floor(heightTotal / 2);
+    if (height <= 0) {
+        throw new Error("ICO BMP frame has invalid mask height.");
+    }
+    if (planes !== 1 || bitCount !== 32 || compression !== 0) {
+        throw new Error("ICO BMP frame format unsupported; expected 32-bit BI_RGB.");
+    }
+    const pixelOffset = headerSize;
+    const rowBytes = width * 4;
+    const pixelBytes = rowBytes * height;
+    if (imageData.length < pixelOffset + pixelBytes) {
+        throw new Error("ICO BMP frame is truncated.");
+    }
+    const png = new pngjs_1.PNG({ width, height });
+    for (let y = 0; y < height; y += 1) {
+        const srcY = height - 1 - y;
+        const srcRow = pixelOffset + srcY * rowBytes;
+        const dstRow = y * rowBytes;
+        for (let x = 0; x < width; x += 1) {
+            const src = srcRow + x * 4;
+            const dst = dstRow + x * 4;
+            const b = imageData[src];
+            const g = imageData[src + 1];
+            const r = imageData[src + 2];
+            const a = imageData[src + 3];
+            png.data[dst] = r;
+            png.data[dst + 1] = g;
+            png.data[dst + 2] = b;
+            png.data[dst + 3] = a;
+        }
+    }
+    return pngjs_1.PNG.sync.write(png);
+}
+function convertIcoToPngBuffer(icoBytes) {
+    if (icoBytes.length < 6) {
+        throw new Error("favicon.ico is too small.");
+    }
+    const reserved = icoBytes.readUInt16LE(0);
+    const iconType = icoBytes.readUInt16LE(2);
+    const count = icoBytes.readUInt16LE(4);
+    if (reserved !== 0 || iconType !== 1 || count === 0) {
+        throw new Error("favicon.ico has invalid ICO header.");
+    }
+    if (icoBytes.length < 6 + count * 16) {
+        throw new Error("favicon.ico has truncated directory entries.");
+    }
+    const frames = [];
+    for (let i = 0; i < count; i += 1) {
+        const entryOffset = 6 + i * 16;
+        const width = normalizeIcoSize(icoBytes[entryOffset]);
+        const height = normalizeIcoSize(icoBytes[entryOffset + 1]);
+        const bytesInRes = icoBytes.readUInt32LE(entryOffset + 8);
+        const imageOffset = icoBytes.readUInt32LE(entryOffset + 12);
+        if (bytesInRes === 0)
+            continue;
+        if (imageOffset + bytesInRes > icoBytes.length)
+            continue;
+        frames.push({ width, height, bytesInRes, imageOffset });
+    }
+    if (frames.length === 0) {
+        throw new Error("favicon.ico contains no readable image frames.");
+    }
+    frames.sort((a, b) => {
+        const areaDiff = b.width * b.height - a.width * a.height;
+        if (areaDiff !== 0)
+            return areaDiff;
+        return b.bytesInRes - a.bytesInRes;
+    });
+    const pngSignature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    for (const frame of frames) {
+        const imageData = icoBytes.subarray(frame.imageOffset, frame.imageOffset + frame.bytesInRes);
+        if (imageData.subarray(0, 8).equals(pngSignature)) {
+            return Buffer.from(imageData);
+        }
+    }
+    return decodeIcoBmpToPng(icoBytes.subarray(frames[0].imageOffset, frames[0].imageOffset + frames[0].bytesInRes));
+}
+function renderDesignerPluginQrc() {
+    return `<RCC>
+  <qresource prefix="/anqstdesignerplugin">
+    <file>plugin-icon.png</file>
+  </qresource>
+</RCC>
+`;
+}
+function installDesignerPluginIconAssets(cwd, pluginDir) {
+    const iconTargetPath = node_path_1.default.join(pluginDir, "plugin-icon.png");
+    const qrcTargetPath = node_path_1.default.join(pluginDir, "designerplugin.qrc");
+    const icoBytes = resolveFaviconIcoBuffer(cwd);
+    if (icoBytes === null) {
+        if (node_fs_1.default.existsSync(iconTargetPath))
+            node_fs_1.default.rmSync(iconTargetPath, { force: true });
+        if (node_fs_1.default.existsSync(qrcTargetPath))
+            node_fs_1.default.rmSync(qrcTargetPath, { force: true });
+        return { hasIcon: false };
+    }
+    const pngBytes = convertIcoToPngBuffer(icoBytes);
+    node_fs_1.default.writeFileSync(iconTargetPath, pngBytes);
+    node_fs_1.default.writeFileSync(qrcTargetPath, renderDesignerPluginQrc(), "utf8");
+    return { hasIcon: true };
+}
+function renderQtDesignerPluginCpp(widgetName, widgetCategory, hasIcon) {
+    const pluginClass = `${widgetName}DesignerPlugin`;
+    const widgetClass = `${widgetName}::${widgetName}`;
+    const groupName = escapeCppStringLiteral(widgetCategory);
+    const iconExpression = hasIcon
+        ? 'QIcon(QStringLiteral(":/anqstdesignerplugin/plugin-icon.png"))'
+        : "QIcon()";
+    return `#include <QtUiPlugin/QDesignerCustomWidgetInterface>
+#include <QIcon>
+#include <QObject>
+#include <QString>
+#include <QWidget>
+#include "include/${widgetName}.h"
+
+class ${pluginClass} final : public QObject, public QDesignerCustomWidgetInterface {
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidgetInterface")
+    Q_INTERFACES(QDesignerCustomWidgetInterface)
+
+public:
+    explicit ${pluginClass}(QObject* parent = nullptr) : QObject(parent) {}
+
+    QString name() const override { return QStringLiteral("${widgetClass}"); }
+    QString group() const override { return QStringLiteral("${groupName}"); }
+    QIcon icon() const override { return ${iconExpression}; }
+    QString toolTip() const override { return QStringLiteral("${widgetName} generated by AnQst."); }
+    QString whatsThis() const override { return QStringLiteral("${widgetName} generated by AnQst."); }
+    bool isContainer() const override { return false; }
+    QString includeFile() const override { return QStringLiteral("include/${widgetName}.h"); }
+    QWidget* createWidget(QWidget* parent) override {
+        auto* widget = new ${widgetClass}(parent);
+        widget->setProperty("anqstDesignerContext", true);
+        return widget;
+    }
+    bool isInitialized() const override { return true; }
+    void initialize(QDesignerFormEditorInterface*) override {}
+
+    QString domXml() const override {
+        return QStringLiteral(
+            "<ui language=\\"c++\\">\\n"
+            "  <widget class=\\"${widgetClass}\\" name=\\"${widgetName.toLowerCase()}\\">\\n"
+            "  </widget>\\n"
+            "</ui>\\n");
+    }
+};
+
+#include "${pluginClass}.moc"
+`;
+}
+function renderQtDesignerPluginCMake(widgetName, hasIcon) {
+    const widgetTarget = `${widgetName}Widget`;
+    const pluginTarget = `${widgetName}DesignerPlugin`;
+    const resourceLine = hasIcon ? "    \"${CMAKE_CURRENT_LIST_DIR}/designerplugin.qrc\"\n" : "";
+    return `cmake_minimum_required(VERSION 3.21)
+project(${pluginTarget} LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTORCC ON)
+
+set(ANQST_PROJECT_ROOT "\${CMAKE_CURRENT_LIST_DIR}/../../../../../../..")
+set(ANQST_WIDGET_DIR "\${CMAKE_CURRENT_LIST_DIR}/..")
+set(ANQST_WEBBASE_DIR "" CACHE PATH "Path to AnQstWebBase source directory")
+
+if(NOT EXISTS "\${ANQST_WIDGET_DIR}/CMakeLists.txt")
+    message(FATAL_ERROR "Missing generated widget CMake project at \${ANQST_WIDGET_DIR}. Run 'anqst build' first.")
+endif()
+
+if(NOT ANQST_WEBBASE_DIR)
+    foreach(candidate
+        "\${ANQST_PROJECT_ROOT}/AnQstWidget/AnQstWebBase"
+        "\${ANQST_PROJECT_ROOT}/../AnQstWidget/AnQstWebBase"
+        "\${ANQST_PROJECT_ROOT}/../../AnQstWidget/AnQstWebBase"
+        "\${ANQST_PROJECT_ROOT}/../../../AnQstWidget/AnQstWebBase")
+        if(EXISTS "\${candidate}/CMakeLists.txt")
+            set(ANQST_WEBBASE_DIR "\${candidate}")
+            break()
+        endif()
+    endforeach()
+endif()
+
+if(NOT ANQST_WEBBASE_DIR OR NOT EXISTS "\${ANQST_WEBBASE_DIR}/CMakeLists.txt")
+    message(FATAL_ERROR "Unable to locate AnQstWebBase sources. Set -DANQST_WEBBASE_DIR=<path/to/AnQstWidget/AnQstWebBase>.")
+endif()
+
+find_package(Qt5 REQUIRED COMPONENTS Core Widgets UiPlugin)
+
+set(ANQSTWEBBASE_BUILD_TESTS OFF CACHE BOOL "Build AnQstWebBase unit tests" FORCE)
+if(NOT TARGET anqstwebhostbase)
+    add_subdirectory("\${ANQST_WEBBASE_DIR}" "\${CMAKE_CURRENT_BINARY_DIR}/anqstwebbase")
+endif()
+
+if(NOT TARGET ${widgetTarget})
+    add_subdirectory("\${ANQST_WIDGET_DIR}" "\${CMAKE_CURRENT_BINARY_DIR}/generated-widget")
+endif()
+
+add_library(${pluginTarget} MODULE
+    "\${CMAKE_CURRENT_LIST_DIR}/${pluginTarget}.cpp"
+${resourceLine})
+target_include_directories(${pluginTarget}
+    PRIVATE
+        "\${ANQST_WIDGET_DIR}"
+        "\${ANQST_WIDGET_DIR}/include"
+)
+target_link_libraries(${pluginTarget}
+    PRIVATE
+        ${widgetTarget}
+        Qt5::Core
+        Qt5::Widgets
+        Qt5::UiPlugin
+)
+set_target_properties(${pluginTarget} PROPERTIES
+    PREFIX ""
+)
+`;
+}
+function installQtDesignerPluginCMake(cwd, widgetName, options = {}) {
+    const pluginDir = (0, layout_1.resolveGeneratedLayoutPaths)(cwd, widgetName).designerPluginRoot;
+    node_fs_1.default.mkdirSync(pluginDir, { recursive: true });
+    const assets = installDesignerPluginIconAssets(cwd, pluginDir);
+    const pluginTarget = `${widgetName}DesignerPlugin`;
+    const widgetCategory = options.widgetCategory ?? "AnQst Widgets";
+    node_fs_1.default.writeFileSync(node_path_1.default.join(pluginDir, "CMakeLists.txt"), withBuildStamp(`backend/cpp/qt/${generatedCppLibraryDirName(widgetName)}/designerPlugin/CMakeLists.txt`, renderQtDesignerPluginCMake(widgetName, assets.hasIcon)), "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(pluginDir, `${pluginTarget}.cpp`), withBuildStamp(`backend/cpp/qt/${generatedCppLibraryDirName(widgetName)}/designerPlugin/${pluginTarget}.cpp`, renderQtDesignerPluginCpp(widgetName, widgetCategory, assets.hasIcon)), "utf8");
 }