@dusted/anqst 0.1.0 → 0.1.1

package/dist/src/app.js

@@ -12,11 +12,21 @@ exports.runCommand = runCommand;
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_child_process_1 = require("node:child_process");
-const parser_1 = require("./parser");
-const verify_1 = require("./verify");
 const errors_1 = require("./errors");
 const emit_1 = require("./emit");
 const project_1 = require("./project");
+const backend_1 = require("./backend");
+const ANQSTGEN_ACTIVE_STAMP_FILE = ".anqstgen-version-active.json";
+function generationTargetsForBackend(backendId, targets) {
+    if (backendId !== "tsc")
+        return targets;
+    // tsc backend currently supports QWidget and node_express_ws emitters only.
+    return {
+        emitQWidget: targets.emitQWidget,
+        emitAngularService: false,
+        emitNodeExpressWs: targets.emitNodeExpressWs
+    };
+}
 function renderHelp() {
     return [
         "Usage:",
@@ -25,48 +35,64 @@ function renderHelp() {
         "Commands:",
         "  instill <WidgetName>       Initialize AnQst in current npm project",
         "  test                        Verify package.json AnQst spec",
-        "  build                       Generate artifacts from package.json AnQst spec",
-        "  generate <specFile>         Generate artifacts from explicit spec file",
-        "  verify <specFile>           Verify explicit spec file only",
+        "  build [--backend <id>] [--designerplugin[=true|false]]      Generate artifacts from package.json AnQst spec",
+        "  generate <specFile> [--backend <id>]  Generate artifacts from explicit spec file",
+        "  verify <specFile> [--backend <id>]    Verify explicit spec file only",
         "  clean <path> [-f|--force]   Remove generated artifacts under path",
         "",
         "Options:",
+        "  --backend <id>              Backend for build/generate/verify: ast|tsc",
+        "  --designerplugin            Build Qt Designer plugin (build command only, tsc + QWidget)",
         "  -h, --help                  Show this help output"
     ].join("\n");
 }
 function usageFor(command) {
     if (command === "instill")
         return "Usage: anqst instill <WidgetName>";
+    if (command === "build")
+        return "Usage: anqst build [--backend <id>] [--designerplugin[=true|false]]";
     if (command === "verify")
-        return "Usage: anqst verify <specFile>";
+        return "Usage: anqst verify <specFile> [--backend <id>]";
     if (command === "generate")
-        return "Usage: anqst generate <specFile>";
+        return "Usage: anqst generate <specFile> [--backend <id>]";
     if (command === "clean")
         return "Usage: anqst clean <path> [-f|--force]";
     return renderHelp();
 }
-function runVerify(specArg) {
+function runVerify(specArg, backendId = "ast") {
     const specPath = node_path_1.default.resolve(process.cwd(), specArg);
-    const parsed = (0, parser_1.parseSpecFile)(specPath);
-    const verification = (0, verify_1.verifySpec)(parsed);
+    const backend = (0, backend_1.resolveBackend)(backendId);
+    const parsed = backend.parseSpecFile(specPath);
+    const verification = backend.verifySpec(parsed);
     return {
         success: true,
         message: verification.message
     };
 }
-function runGenerate(specArg) {
+function runGenerate(specArg, backendId = "ast") {
     const cwd = process.cwd();
     const specPath = node_path_1.default.resolve(cwd, specArg);
-    const parsed = (0, parser_1.parseSpecFile)(specPath);
-    const verification = (0, verify_1.verifySpec)(parsed);
-    const generationTargets = resolveGenerationTargetsFromCwd(cwd);
-    const outputs = (0, emit_1.generateOutputs)(parsed, generationTargets);
-    (0, emit_1.writeGeneratedOutputs)(cwd, outputs);
-    if (generationTargets.emitAngularService) {
-        (0, emit_1.installTypeScriptOutputs)(cwd);
+    const backend = (0, backend_1.resolveBackend)(backendId);
+    const parsed = backend.parseSpecFile(specPath);
+    const verification = backend.verifySpec(parsed);
+    const generationTargets = generationTargetsForBackend(backend.id, resolveGenerationTargetsFromCwd(cwd));
+    const outputs = backend.generateOutputs(parsed, generationTargets);
+    if (backend.emitsArtifacts) {
+        (0, emit_1.writeGeneratedOutputs)(cwd, outputs);
+        if (generationTargets.emitAngularService) {
+            (0, emit_1.installTypeScriptOutputs)(cwd);
+        }
+        if (generationTargets.emitQWidget) {
+            (0, emit_1.installQtIntegrationCMake)(cwd, parsed.widgetName);
+        }
     }
-    if (generationTargets.emitQWidget) {
-        (0, emit_1.installQtIntegrationCMake)(cwd, parsed.widgetName);
+    else {
+        const relativeSpecFile = normalizeSlashes(node_path_1.default.relative(cwd, specPath));
+        return {
+            success: true,
+            verificationMessage: verification.message,
+            message: `\nAnQst spec ${relativeSpecFile} built.\n    Backend '${backend.id}' is a non-emitting skeleton. No artifacts were generated.\n`
+        };
     }
     const relativeSpecFile = normalizeSlashes(node_path_1.default.relative(cwd, specPath));
     const relativeTypeScriptInstallPath = normalizeSlashes(node_path_1.default.relative(cwd, node_path_1.default.join(cwd, "src", "anqst-generated")));
@@ -96,64 +122,271 @@ function runGenerate(specArg) {
 }
 function runTest(cwd) {
     const specPath = (0, project_1.resolveAnQstSpecPath)(cwd);
-    const parsed = (0, parser_1.parseSpecFile)(specPath);
-    const verification = (0, verify_1.verifySpec)(parsed);
+    const backend = (0, backend_1.resolveBackend)("ast");
+    const parsed = backend.parseSpecFile(specPath);
+    const verification = backend.verifySpec(parsed);
     return {
         success: true,
         message: verification.message
     };
 }
-function runBuild(cwd) {
-    const specPath = (0, project_1.resolveAnQstSpecPath)(cwd);
-    const generationTargets = resolveGenerationTargetsFromCwd(cwd, true);
-    const parsed = (0, parser_1.parseSpecFile)(specPath);
-    (0, verify_1.verifySpec)(parsed);
-    const outputs = (0, emit_1.generateOutputs)(parsed, generationTargets);
-    (0, emit_1.writeGeneratedOutputs)(cwd, outputs);
-    if (generationTargets.emitAngularService) {
-        (0, emit_1.installTypeScriptOutputs)(cwd);
+function resolveAnQstGenRoot() {
+    return node_path_1.default.resolve(__dirname, "..", "..");
+}
+function readActiveBuildStamp() {
+    if (process.env.ANQST_BUILD_STAMP && process.env.ANQST_BUILD_STAMP.trim().length > 0) {
+        return process.env.ANQST_BUILD_STAMP.trim();
     }
-    if (generationTargets.emitQWidget) {
-        (0, emit_1.installQtIntegrationCMake)(cwd, parsed.widgetName);
+    const activePath = node_path_1.default.join(resolveAnQstGenRoot(), ANQSTGEN_ACTIVE_STAMP_FILE);
+    if (!node_fs_1.default.existsSync(activePath)) {
+        return "unknown_build_0";
     }
-    const hasAngularProject = generationTargets.emitQWidget && node_fs_1.default.existsSync(node_path_1.default.join(cwd, "angular.json"));
-    if (hasAngularProject && generationTargets.emitQWidget) {
-        const angularBuild = (0, node_child_process_1.spawnSync)("npx", ["ng", "build", "--configuration", "production"], {
-            cwd,
-            stdio: "inherit",
-            shell: process.platform === "win32"
-        });
-        if (angularBuild.status !== 0) {
-            throw new errors_1.VerifyError("Angular build failed while preparing embedded widget assets.");
+    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();
         }
     }
-    if (generationTargets.emitQWidget) {
-        const embedded = (0, emit_1.installEmbeddedWebBundle)(cwd, parsed.widgetName);
-        if (hasAngularProject && !embedded) {
-            throw new errors_1.VerifyError("Unable to embed Angular output. Ensure ng build produced a dist bundle with index.html.");
-        }
+    catch {
+        // Fallback to deterministic unknown stamp.
     }
-    if (!generationTargets.emitAngularService && !generationTargets.emitQWidget && !generationTargets.emitNodeExpressWs) {
+    return "unknown_build_0";
+}
+function runDesignerPluginBuild(cwd) {
+    const pluginSourceDir = node_path_1.default.join(cwd, "anqst-cmake", "designerplugin");
+    const pluginBuildDir = node_path_1.default.join(cwd, "anqst-cmake", "build-designerplugin");
+    const webBaseDir = process.env.ANQST_WEBBASE_DIR?.trim();
+    if (!webBaseDir) {
+        throw new errors_1.VerifyError("Missing ANQST_WEBBASE_DIR environment variable for --designerplugin build.");
+    }
+    const configureArgs = [
+        "-S",
+        pluginSourceDir,
+        "-B",
+        pluginBuildDir,
+        "-DCMAKE_BUILD_TYPE=Release",
+        `-DANQST_WEBBASE_DIR=${webBaseDir}`
+    ];
+    const configure = (0, node_child_process_1.spawnSync)("cmake", configureArgs, {
+        cwd,
+        stdio: "inherit",
+        shell: process.platform === "win32"
+    });
+    if (configure.status !== 0) {
+        throw new errors_1.VerifyError([
+            "CMake configure failed while building Qt Designer plugin.",
+            "If CMake reports missing Qt5UiPlugin, install qttools5-dev (Ubuntu/Debian) and re-run install_dependencies.sh."
+        ].join(" "));
+    }
+    const build = (0, node_child_process_1.spawnSync)("cmake", ["--build", pluginBuildDir, "--config", "Release"], {
+        cwd,
+        stdio: "inherit",
+        shell: process.platform === "win32"
+    });
+    if (build.status !== 0) {
+        throw new errors_1.VerifyError("CMake build failed while compiling Qt Designer plugin.");
+    }
+}
+function runBuild(cwd, backendId = "ast", designerPlugin = false) {
+    const buildVersion = readActiveBuildStamp();
+    process.env.ANQST_BUILD_STAMP = buildVersion;
+    try {
+        const backend = (0, backend_1.resolveBackend)(backendId);
+        const specPath = (0, project_1.resolveAnQstSpecPath)(cwd);
+        const generationTargets = generationTargetsForBackend(backend.id, resolveGenerationTargetsFromCwd(cwd, true));
+        const parsed = backend.parseSpecFile(specPath);
+        backend.verifySpec(parsed);
+        const outputs = backend.generateOutputs(parsed, generationTargets);
+        if (backend.emitsArtifacts) {
+            (0, emit_1.writeGeneratedOutputs)(cwd, outputs);
+            if (generationTargets.emitAngularService) {
+                (0, emit_1.installTypeScriptOutputs)(cwd);
+            }
+            if (generationTargets.emitQWidget) {
+                (0, emit_1.installQtIntegrationCMake)(cwd, parsed.widgetName);
+            }
+        }
+        else {
+            return {
+                success: true,
+                message: `Build completed: backend '${backend.id}' is a non-emitting skeleton; no artifacts were generated`
+            };
+        }
+        const hasAngularProject = generationTargets.emitQWidget && node_fs_1.default.existsSync(node_path_1.default.join(cwd, "angular.json"));
+        if (hasAngularProject && generationTargets.emitQWidget) {
+            const angularBuild = (0, node_child_process_1.spawnSync)("npx", ["ng", "build", "--configuration", "production"], {
+                cwd,
+                stdio: "inherit",
+                shell: process.platform === "win32"
+            });
+            if (angularBuild.status !== 0) {
+                throw new errors_1.VerifyError("Angular build failed while preparing embedded widget assets.");
+            }
+        }
+        if (generationTargets.emitQWidget) {
+            const embedded = (0, emit_1.installEmbeddedWebBundle)(cwd, parsed.widgetName);
+            if (hasAngularProject && !embedded) {
+                throw new errors_1.VerifyError("Unable to embed Angular output. Ensure ng build produced a dist bundle with index.html.");
+            }
+        }
+        let designerPluginBuilt = false;
+        if (designerPlugin) {
+            if (backend.id !== "tsc") {
+                console.warn("[AnQst] --designerplugin is only supported with --backend tsc. Skipping designer plugin build.");
+            }
+            else if (!generationTargets.emitQWidget) {
+                console.warn("[AnQst] --designerplugin requested but QWidget target is not enabled. Skipping designer plugin build.");
+            }
+            else {
+                const widgetCategory = (0, project_1.resolveAnQstWidgetCategory)(cwd);
+                (0, emit_1.installQtDesignerPluginCMake)(cwd, parsed.widgetName, { widgetCategory });
+                runDesignerPluginBuild(cwd);
+                designerPluginBuilt = true;
+            }
+        }
+        if (!generationTargets.emitAngularService && !generationTargets.emitQWidget && !generationTargets.emitNodeExpressWs) {
+            return {
+                success: true,
+                message: [
+                    "Build completed.",
+                    `    anqst version ${buildVersion}`,
+                    "    No outputs selected by AnQst.generate."
+                ].join("\n")
+            };
+        }
+        const detailLines = [];
+        if (generationTargets.emitAngularService) {
+            detailLines.push("    Target AngularService:");
+            detailLines.push("      - Services output: src/anqst-generated/services");
+            detailLines.push("      - Types output: src/anqst-generated/types");
+        }
+        if (generationTargets.emitQWidget) {
+            detailLines.push("    Target QWidget:");
+            detailLines.push("      - Qt integration CMake: anqst-cmake/CMakeLists.txt");
+            detailLines.push(`      - Widget output root: generated_output/${parsed.widgetName}_QtWidget`);
+            detailLines.push("      - Embedded web assets refreshed from Angular build");
+        }
+        if (generationTargets.emitNodeExpressWs) {
+            detailLines.push("    Target node_express_ws:");
+            detailLines.push(`      - Module output root: generated_output/${parsed.widgetName}_node_express_ws`);
+        }
+        if (designerPluginBuilt) {
+            const pluginBinaryPath = normalizeSlashes(node_path_1.default.join("anqst-cmake", "build-designerplugin", designerPluginBinaryName(parsed.widgetName)));
+            detailLines.push("    Target QtDesignerPlugin:");
+            detailLines.push("      - Build output: anqst-cmake/build-designerplugin");
+            detailLines.push(`      - Plugin binary: ${pluginBinaryPath}`);
+            detailLines.push("      - Install target dir: <QT_INSTALL_PLUGINS>/designer");
+            detailLines.push("      - Discover QT_INSTALL_PLUGINS: qmake -query QT_INSTALL_PLUGINS");
+            detailLines.push(`      - Example install: cp ${pluginBinaryPath} "$(qmake -query QT_INSTALL_PLUGINS)/designer/"`);
+            detailLines.push(`      - User-local install: mkdir -p "$HOME/.local/lib/qt5/plugins/designer" && cp ${pluginBinaryPath} "$HOME/.local/lib/qt5/plugins/designer/"`);
+        }
         return {
             success: true,
-            message: "Build completed: no outputs selected by AnQst.generate"
+            message: [
+                "Build completed.",
+                `    anqst version ${buildVersion}`,
+                ...detailLines
+            ].join("\n")
         };
     }
-    const parts = [];
-    if (generationTargets.emitAngularService) {
-        parts.push("TypeScript installed to src/anqst-generated");
+    finally {
+        delete process.env.ANQST_BUILD_STAMP;
     }
-    if (generationTargets.emitQWidget) {
-        parts.push("Qt integration CMake emitted to anqst-cmake/");
-        parts.push("C++ widget library refreshed with embedded web assets");
+}
+function parseBackendCommandArgs(commandName, specArg, extraArgs, requireSpec) {
+    const allArgs = [specArg, ...extraArgs].filter((arg) => typeof arg === "string" && arg.length > 0);
+    let backendId = "ast";
+    const positional = [];
+    for (let i = 0; i < allArgs.length; i += 1) {
+        const arg = allArgs[i];
+        if (arg === "--backend") {
+            const value = allArgs[i + 1];
+            if (!value || value.startsWith("-")) {
+                throw new Error(`Missing value for --backend. ${usageFor(commandName)}`);
+            }
+            if (!(0, backend_1.isBackendId)(value)) {
+                throw new Error(`Unknown backend '${value}'. Allowed backends: ast, tsc.`);
+            }
+            backendId = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--backend=")) {
+            const value = arg.slice("--backend=".length);
+            if (!(0, backend_1.isBackendId)(value)) {
+                throw new Error(`Unknown backend '${value}'. Allowed backends: ast, tsc.`);
+            }
+            backendId = value;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`Unknown ${commandName} flag '${arg}'. ${usageFor(commandName)}`);
+        }
+        positional.push(arg);
     }
-    if (generationTargets.emitNodeExpressWs) {
-        parts.push(`Node Express WS module emitted to generated_output/${parsed.widgetName}_node_express_ws`);
+    if (requireSpec) {
+        if (positional.length !== 1) {
+            throw new Error(usageFor(commandName));
+        }
+        return { backendId, specArg: positional[0] };
     }
-    return {
-        success: true,
-        message: `Build completed: ${parts.join(", ")}`
-    };
+    if (positional.length > 0) {
+        throw new Error(`Unexpected extra argument '${positional[0]}'. ${usageFor(commandName)}`);
+    }
+    return { backendId };
+}
+function parseBuildCommandArgs(specArg, extraArgs) {
+    const allArgs = [specArg, ...extraArgs].filter((arg) => typeof arg === "string" && arg.length > 0);
+    let backendId = "ast";
+    let designerPlugin = false;
+    const positional = [];
+    for (let i = 0; i < allArgs.length; i += 1) {
+        const arg = allArgs[i];
+        if (arg === "--backend") {
+            const value = allArgs[i + 1];
+            if (!value || value.startsWith("-")) {
+                throw new Error(`Missing value for --backend. ${usageFor("build")}`);
+            }
+            if (!(0, backend_1.isBackendId)(value)) {
+                throw new Error(`Unknown backend '${value}'. Allowed backends: ast, tsc.`);
+            }
+            backendId = value;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--backend=")) {
+            const value = arg.slice("--backend=".length);
+            if (!(0, backend_1.isBackendId)(value)) {
+                throw new Error(`Unknown backend '${value}'. Allowed backends: ast, tsc.`);
+            }
+            backendId = value;
+            continue;
+        }
+        if (arg === "--designerplugin") {
+            const value = allArgs[i + 1];
+            if (value && !value.startsWith("-")) {
+                designerPlugin = value.toLowerCase() === "true";
+                i += 1;
+            }
+            else {
+                designerPlugin = true;
+            }
+            continue;
+        }
+        if (arg.startsWith("--designerplugin=")) {
+            const value = arg.slice("--designerplugin=".length);
+            designerPlugin = value.toLowerCase() === "true";
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`Unknown build flag '${arg}'. ${usageFor("build")}`);
+        }
+        positional.push(arg);
+    }
+    if (positional.length > 0) {
+        throw new Error(`Unexpected extra argument '${positional[0]}'. ${usageFor("build")}`);
+    }
+    return { backendId, designerPlugin };
 }
 function parseCleanCommandArgs(specArg, extraArgs) {
     const allArgs = [specArg, ...extraArgs].filter((arg) => typeof arg === "string" && arg.length > 0);
@@ -279,7 +512,7 @@ function runClean(pathArg, force) {
         };
     }
     const specPath = resolveAnQstSpecFromPackage(targetRoot);
-    const parsed = (0, parser_1.parseSpecFile)(specPath);
+    const parsed = (0, backend_1.resolveBackend)("ast").parseSpecFile(specPath);
     const widgetDirs = [
         node_path_1.default.join("generated_output", `${parsed.widgetName}_QtWidget`),
         node_path_1.default.join("generated_output", `${parsed.widgetName}_node_express_ws`),
@@ -296,6 +529,23 @@ function runClean(pathArg, force) {
 function normalizeSlashes(inputPath) {
     return inputPath.split(node_path_1.default.sep).join("/");
 }
+function designerPluginBinaryName(widgetName) {
+    const targetName = `${widgetName}DesignerPlugin`;
+    if (process.platform === "win32") {
+        return `${targetName}.dll`;
+    }
+    if (process.platform === "darwin") {
+        return `${targetName}.dylib`;
+    }
+    return `${targetName}.so`;
+}
+function renderInstallAliasMessage() {
+    const useColor = process.stdout.isTTY;
+    const text = "[AnQst] 'install' spotted. Muscle memory is undefeated - running 'instill' for you.";
+    if (!useColor)
+        return text;
+    return `\x1b[38;5;214m${text}\x1b[0m`;
+}
 function runCommand(command, specArg, extraArgs = []) {
     try {
         if (!command) {
@@ -306,7 +556,11 @@ function runCommand(command, specArg, extraArgs = []) {
             console.log(renderHelp());
             return 0;
         }
-        if (command === "instill") {
+        const normalizedCommand = command === "install" ? "instill" : command;
+        if (command === "install") {
+            console.log(renderInstallAliasMessage());
+        }
+        if (normalizedCommand === "instill") {
             if (!specArg) {
                 console.error(usageFor("instill"));
                 return 1;
@@ -315,38 +569,33 @@ function runCommand(command, specArg, extraArgs = []) {
             console.log(msg);
             return 0;
         }
-        if (command === "test") {
+        if (normalizedCommand === "test") {
             const res = runTest(process.cwd());
             console.log(res.message);
             return 0;
         }
-        if (command === "build") {
-            const res = runBuild(process.cwd());
+        if (normalizedCommand === "build") {
+            const parsedArgs = parseBuildCommandArgs(specArg, extraArgs);
+            const res = runBuild(process.cwd(), parsedArgs.backendId, parsedArgs.designerPlugin);
             console.log(res.message);
             return 0;
         }
-        if (command === "verify") {
-            if (!specArg) {
-                console.error(usageFor("verify"));
-                return 1;
-            }
-            const res = runVerify(specArg);
+        if (normalizedCommand === "verify") {
+            const parsedArgs = parseBackendCommandArgs("verify", specArg, extraArgs, true);
+            const res = runVerify(parsedArgs.specArg, parsedArgs.backendId);
             console.log(res.message);
             return 0;
         }
-        if (command === "generate") {
-            if (!specArg) {
-                console.error(usageFor("generate"));
-                return 1;
-            }
-            const res = runGenerate(specArg);
+        if (normalizedCommand === "generate") {
+            const parsedArgs = parseBackendCommandArgs("generate", specArg, extraArgs, true);
+            const res = runGenerate(parsedArgs.specArg, parsedArgs.backendId);
             if (res.verificationMessage) {
                 console.log(res.verificationMessage);
             }
             console.log(res.message);
             return 0;
         }
-        if (command === "clean") {
+        if (normalizedCommand === "clean") {
             const parsed = parseCleanCommandArgs(specArg, extraArgs);
             const res = runClean(parsed.targetPathArg, parsed.force);
             console.log(res.message);

package/dist/src/backend/ast/emit.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOutputs = void 0;
+var emit_1 = require("../../emit");
+Object.defineProperty(exports, "generateOutputs", { enumerable: true, get: function () { return emit_1.generateOutputs; } });

package/dist/src/backend/ast/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astBackend = void 0;
+const emit_1 = require("./emit");
+const parser_1 = require("./parser");
+const verify_1 = require("./verify");
+exports.astBackend = {
+    id: "ast",
+    parseSpecFile: parser_1.parseSpecFile,
+    verifySpec: verify_1.verifySpec,
+    generateOutputs: emit_1.generateOutputs,
+    emitsArtifacts: true
+};

package/dist/src/backend/ast/parser.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSpecFile = void 0;
+var parser_1 = require("../../parser");
+Object.defineProperty(exports, "parseSpecFile", { enumerable: true, get: function () { return parser_1.parseSpecFile; } });

package/dist/src/backend/ast/verify.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySpec = void 0;
+var verify_1 = require("../../verify");
+Object.defineProperty(exports, "verifySpec", { enumerable: true, get: function () { return verify_1.verifySpec; } });

package/dist/src/backend/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBackend = resolveBackend;
+exports.isBackendId = isBackendId;
+const ast_1 = require("./ast");
+const tsc_1 = require("./tsc");
+const backends = {
+    ast: ast_1.astBackend,
+    tsc: tsc_1.tscBackend
+};
+function resolveBackend(backendId) {
+    return backends[backendId];
+}
+function isBackendId(value) {
+    return value === "ast" || value === "tsc";
+}

package/dist/src/backend/tsc/debug-dump.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDebugEnabled = isDebugEnabled;
+exports.writeDebugFile = writeDebugFile;
+exports.inspectText = inspectText;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = __importDefault(require("node:util"));
+function isDebugEnabled() {
+    return process.env.ANQST_DEBUG === "true";
+}
+function baseIntermediateDir(cwd) {
+    return node_path_1.default.join(cwd, "generated_output", "intermediate");
+}
+function writeDebugFile(cwd, relativePath, content) {
+    if (!isDebugEnabled())
+        return;
+    try {
+        const targetPath = node_path_1.default.join(baseIntermediateDir(cwd), relativePath);
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(targetPath), { recursive: true });
+        node_fs_1.default.writeFileSync(targetPath, content, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[AnQst][debug] Failed writing ${relativePath}: ${message}`);
+    }
+}
+function inspectText(value) {
+    return node_util_1.default.inspect(value, {
+        depth: null,
+        maxArrayLength: null,
+        maxStringLength: null,
+        breakLength: 120,
+        compact: false
+    });
+}

package/dist/src/backend/tsc/emit-cpp.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitCppQWidget = emitCppQWidget;
+const emit_1 = require("../ast/emit");
+function emitCppQWidget(spec, options) {
+    if (!options.emitQWidget)
+        return {};
+    return (0, emit_1.generateOutputs)(spec, {
+        emitQWidget: true,
+        emitAngularService: false,
+        emitNodeExpressWs: false
+    });
+}

package/dist/src/backend/tsc/emit-node.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitNodeExpressWs = emitNodeExpressWs;
+const emit_1 = require("../ast/emit");
+function emitNodeExpressWs(spec, options) {
+    if (!options.emitNodeExpressWs)
+        return {};
+    return (0, emit_1.generateOutputs)(spec, {
+        emitQWidget: false,
+        emitAngularService: false,
+        emitNodeExpressWs: true
+    });
+}