@dusted/anqst 0.1.0 → 0.1.2

package/dist/src/layout.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANQST_LAYOUT_VERSION = exports.ANQST_GENERATED_DIRNAME = exports.ANQST_ROOT_DIRNAME = void 0;
+exports.normalizeSlashes = normalizeSlashes;
+exports.anqstRootDir = anqstRootDir;
+exports.anqstGeneratedRootDir = anqstGeneratedRootDir;
+exports.anqstDebugIntermediateRootDir = anqstDebugIntermediateRootDir;
+exports.anqstSpecFileName = anqstSpecFileName;
+exports.anqstSettingsFileName = anqstSettingsFileName;
+exports.anqstSettingsRelativePath = anqstSettingsRelativePath;
+exports.generatedFrontendDirName = generatedFrontendDirName;
+exports.generatedNodeExpressDirName = generatedNodeExpressDirName;
+exports.generatedQtWidgetDirName = generatedQtWidgetDirName;
+exports.resolveGeneratedLayoutPaths = resolveGeneratedLayoutPaths;
+exports.toProjectRelative = toProjectRelative;
+const node_path_1 = __importDefault(require("node:path"));
+exports.ANQST_ROOT_DIRNAME = "AnQst";
+exports.ANQST_GENERATED_DIRNAME = "generated";
+exports.ANQST_LAYOUT_VERSION = 2;
+function normalizeSlashes(inputPath) {
+    return inputPath.split(node_path_1.default.sep).join("/");
+}
+function anqstRootDir(cwd) {
+    return node_path_1.default.join(cwd, exports.ANQST_ROOT_DIRNAME);
+}
+function anqstGeneratedRootDir(cwd) {
+    return node_path_1.default.join(anqstRootDir(cwd), exports.ANQST_GENERATED_DIRNAME);
+}
+function anqstDebugIntermediateRootDir(cwd) {
+    return node_path_1.default.join(anqstGeneratedRootDir(cwd), "debug", "intermediate");
+}
+function anqstSpecFileName(widgetName) {
+    return `${widgetName}.AnQst.d.ts`;
+}
+function anqstSettingsFileName(widgetName) {
+    return `${widgetName}.settings.json`;
+}
+function anqstSettingsRelativePath(widgetName) {
+    return `./${exports.ANQST_ROOT_DIRNAME}/${anqstSettingsFileName(widgetName)}`;
+}
+function generatedFrontendDirName(widgetName) {
+    return `${widgetName}_Angular`;
+}
+function generatedNodeExpressDirName(widgetName) {
+    return `${widgetName}_anQst`;
+}
+function generatedQtWidgetDirName(widgetName) {
+    return `${widgetName}_widget`;
+}
+function resolveGeneratedLayoutPaths(cwd, widgetName) {
+    const generatedRoot = anqstGeneratedRootDir(cwd);
+    const cppQtWidgetRoot = node_path_1.default.join(generatedRoot, "backend", "cpp", "qt", generatedQtWidgetDirName(widgetName));
+    const designerPluginRoot = node_path_1.default.join(cppQtWidgetRoot, "designerPlugin");
+    return {
+        generatedRoot,
+        frontendRoot: node_path_1.default.join(generatedRoot, "frontend", generatedFrontendDirName(widgetName)),
+        nodeExpressRoot: node_path_1.default.join(generatedRoot, "backend", "node", "express", generatedNodeExpressDirName(widgetName)),
+        cppCmakeRoot: node_path_1.default.join(generatedRoot, "backend", "cpp", "cmake"),
+        cppQtWidgetRoot,
+        designerPluginRoot,
+        designerPluginBuildRoot: node_path_1.default.join(designerPluginRoot, "build"),
+        debugIntermediateRoot: anqstDebugIntermediateRootDir(cwd)
+    };
+}
+function toProjectRelative(cwd, absolutePath) {
+    return normalizeSlashes(node_path_1.default.relative(cwd, absolutePath));
+}

package/dist/src/parser.js

@@ -8,6 +8,9 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const typescript_1 = __importDefault(require("typescript"));
 const errors_1 = require("./errors");
+const program_1 = require("./program");
+const typegraph_1 = require("./typegraph");
+const debug_dump_1 = require("./debug-dump");
 function locFromNode(source, node) {
     const lc = source.getLineAndCharacterOfPosition(node.getStart(source));
     return {
@@ -207,7 +210,7 @@ function serviceBaseType(iface) {
     }
     return null;
 }
-function parseSpecFile(specFilePath) {
+function parseSpecFileAst(specFilePath) {
     if (!node_fs_1.default.existsSync(specFilePath))
         throw new errors_1.VerifyError(`Spec file does not exist: ${specFilePath}`);
     const text = node_fs_1.default.readFileSync(specFilePath, "utf8");
@@ -257,3 +260,15 @@ function parseSpecFile(specFilePath) {
         specImports: importInfo.specImports
     };
 }
+function parseSpecFile(specFilePath) {
+    (0, program_1.createTscProgramContext)(specFilePath);
+    const parsed = parseSpecFileAst(specFilePath);
+    if ((0, debug_dump_1.isDebugEnabled)()) {
+        (0, debug_dump_1.writeDebugFile)(process.cwd(), "anqstmodel/parsed-before-typegraph.txt", `${(0, debug_dump_1.inspectText)(parsed)}\n`);
+    }
+    const normalized = (0, typegraph_1.applyResolvedTypeGraph)(parsed);
+    if ((0, debug_dump_1.isDebugEnabled)()) {
+        (0, debug_dump_1.writeDebugFile)(process.cwd(), "anqstmodel/parsed-after-typegraph.txt", `${(0, debug_dump_1.inspectText)(normalized)}\n`);
+    }
+    return normalized;
+}

package/dist/src/program.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTscProgramContext = createTscProgramContext;
+exports.getTscProgramContext = getTscProgramContext;
+exports.getProgramDiagnostics = getProgramDiagnostics;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const errors_1 = require("./errors");
+const debug_dump_1 = require("./debug-dump");
+const contextBySpecPath = new Map();
+function diagnosticText(diagnostic) {
+    return typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+}
+function formatDiagnostic(diagnostic) {
+    if (!diagnostic.file || diagnostic.start === undefined) {
+        return diagnosticText(diagnostic);
+    }
+    const pos = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+    return `${diagnostic.file.fileName}:${pos.line + 1}:${pos.character + 1}: ${diagnosticText(diagnostic)}`;
+}
+function dumpSourceFileAst(sourceFile) {
+    const lines = [];
+    lines.push(`== SOURCE FILE ==`);
+    lines.push(sourceFile.fileName);
+    lines.push("");
+    lines.push("== FULL TEXT ==");
+    lines.push(sourceFile.getFullText());
+    lines.push("");
+    lines.push("== AST NODES ==");
+    const walk = (node, depth) => {
+        const indent = "  ".repeat(depth);
+        const kind = typescript_1.default.SyntaxKind[node.kind];
+        const start = node.getStart(sourceFile, false);
+        const end = node.getEnd();
+        const text = node.getText(sourceFile).replace(/\s+/g, " ").slice(0, 160);
+        lines.push(`${indent}${kind} [${start}, ${end}] ${text}`);
+        typescript_1.default.forEachChild(node, (child) => walk(child, depth + 1));
+    };
+    walk(sourceFile, 0);
+    return `${lines.join("\n")}\n`;
+}
+function dumpProgramArtifacts(specPath, rootNames, options, program, sourceFile) {
+    if (!(0, debug_dump_1.isDebugEnabled)())
+        return;
+    const cwd = process.cwd();
+    const diagnostics = typescript_1.default.getPreEmitDiagnostics(program, sourceFile).map(formatDiagnostic);
+    const sourceFiles = program.getSourceFiles().map((sf) => sf.fileName);
+    const contextLines = [
+        `specPath: ${specPath}`,
+        "",
+        "compilerOptions:",
+        (0, debug_dump_1.inspectText)(options),
+        "",
+        "rootNames:",
+        rootNames.join("\n"),
+        "",
+        "diagnostics:",
+        diagnostics.length > 0 ? diagnostics.join("\n") : "(none)"
+    ];
+    (0, debug_dump_1.writeDebugFile)(cwd, node_path_1.default.join("tsc", "program-context.txt"), `${contextLines.join("\n")}\n`);
+    (0, debug_dump_1.writeDebugFile)(cwd, node_path_1.default.join("tsc", "program-files.txt"), `${sourceFiles.join("\n")}\n`);
+    (0, debug_dump_1.writeDebugFile)(cwd, node_path_1.default.join("tsc", "sourcefile-ast.txt"), dumpSourceFileAst(sourceFile));
+}
+function readTsConfigFrom(specPath) {
+    const specDir = node_path_1.default.dirname(specPath);
+    const configPath = typescript_1.default.findConfigFile(specDir, typescript_1.default.sys.fileExists, "tsconfig.json");
+    if (!configPath || !node_fs_1.default.existsSync(configPath)) {
+        return null;
+    }
+    const config = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
+    if (config.error) {
+        throw new errors_1.VerifyError(`Unable to parse tsconfig.json: ${diagnosticText(config.error)}`);
+    }
+    const parsed = typescript_1.default.parseJsonConfigFileContent(config.config, typescript_1.default.sys, node_path_1.default.dirname(configPath), {}, configPath);
+    return { rootNames: parsed.fileNames, options: parsed.options };
+}
+function createTscProgramContext(specPath) {
+    const absoluteSpecPath = node_path_1.default.resolve(specPath);
+    const tsConfig = readTsConfigFrom(absoluteSpecPath);
+    const rootNames = tsConfig ? [...new Set([...tsConfig.rootNames, absoluteSpecPath])] : [absoluteSpecPath];
+    const options = tsConfig?.options ?? {
+        target: typescript_1.default.ScriptTarget.ES2022,
+        module: typescript_1.default.ModuleKind.CommonJS,
+        moduleResolution: typescript_1.default.ModuleResolutionKind.NodeJs,
+        skipLibCheck: true,
+        esModuleInterop: true,
+        strict: false,
+        allowJs: false
+    };
+    const program = typescript_1.default.createProgram({ rootNames, options });
+    const sourceFile = program.getSourceFile(absoluteSpecPath);
+    if (!sourceFile) {
+        throw new errors_1.VerifyError(`Unable to load spec source file into TypeScript program: ${absoluteSpecPath}`);
+    }
+    const context = {
+        specPath: absoluteSpecPath,
+        program,
+        checker: program.getTypeChecker(),
+        sourceFile
+    };
+    dumpProgramArtifacts(absoluteSpecPath, rootNames, options, program, sourceFile);
+    contextBySpecPath.set(absoluteSpecPath, context);
+    return context;
+}
+function getTscProgramContext(specPath) {
+    const absoluteSpecPath = node_path_1.default.resolve(specPath);
+    const existing = contextBySpecPath.get(absoluteSpecPath);
+    if (existing)
+        return existing;
+    return createTscProgramContext(absoluteSpecPath);
+}
+function getProgramDiagnostics(specPath) {
+    const context = getTscProgramContext(specPath);
+    const diagnostics = typescript_1.default.getPreEmitDiagnostics(context.program, context.sourceFile);
+    return diagnostics.map(formatDiagnostic);
+}

package/dist/src/project.js

@@ -5,119 +5,272 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_ANQST_GENERATE_TARGETS = void 0;
 exports.readProjectPackage = readProjectPackage;
+exports.resolveAnQstSettings = resolveAnQstSettings;
 exports.resolveAnQstSpecPath = resolveAnQstSpecPath;
 exports.resolveAnQstGenerateTargets = resolveAnQstGenerateTargets;
-exports.installDslShim = installDslShim;
+exports.resolveAnQstWidgetCategory = resolveAnQstWidgetCategory;
+exports.resolveAnQstWidgetName = resolveAnQstWidgetName;
 exports.buildSpecScaffold = buildSpecScaffold;
 exports.runInstill = runInstill;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const errors_1 = require("./errors");
-exports.DEFAULT_ANQST_GENERATE_TARGETS = ["QWidget", "AngularService", "//DOM", "//node_express_ws"];
+const layout_1 = require("./layout");
+exports.DEFAULT_ANQST_GENERATE_TARGETS = ["QWidget", "AngularService", "node_express_ws"];
+const ANQST_DSL_IMPORT_LINE = 'import type { AnQst } from "@dusted/anqst";';
+const ANQST_BUILD_HOOK = "npx anqst build";
 function readJsonFile(filePath) {
-    const raw = node_fs_1.default.readFileSync(filePath, "utf8");
-    return JSON.parse(raw);
+    try {
+        const raw = node_fs_1.default.readFileSync(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new errors_1.VerifyError(`Unable to parse JSON file '${(0, layout_1.normalizeSlashes)(filePath)}': ${message}`);
+    }
+}
+function ensureObject(value, errorMessage) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new errors_1.VerifyError(errorMessage);
+    }
+    return value;
 }
-function prependScript(existing, prefix) {
-    if (!existing || existing.trim().length === 0)
-        return prefix;
+function ensureBuildHook(existing) {
+    if (!existing || existing.trim().length === 0) {
+        return ANQST_BUILD_HOOK;
+    }
     const trimmed = existing.trim();
-    if (trimmed === prefix || trimmed.startsWith(`${prefix} &&`))
+    if (trimmed === ANQST_BUILD_HOOK || trimmed.startsWith(`${ANQST_BUILD_HOOK} &&`) || trimmed.includes(ANQST_BUILD_HOOK)) {
         return trimmed;
-    return `${prefix} && ${trimmed}`;
+    }
+    return `${ANQST_BUILD_HOOK} && ${trimmed}`;
+}
+function normalizeAnQstImport(sourceText) {
+    const importPattern = /^\s*import\s+(?:type\s+)?\{\s*AnQst\s*\}\s+from\s+["'][^"']+["'];\s*$/m;
+    if (importPattern.test(sourceText)) {
+        const nextText = sourceText.replace(importPattern, ANQST_DSL_IMPORT_LINE);
+        return { nextText, changed: nextText !== sourceText };
+    }
+    return {
+        nextText: `${ANQST_DSL_IMPORT_LINE}\n\n${sourceText}`,
+        changed: true
+    };
+}
+function isSubPath(parentPath, childPath) {
+    const relative = node_path_1.default.relative(parentPath, childPath);
+    if (relative === "") {
+        return true;
+    }
+    return !relative.startsWith("..") && !node_path_1.default.isAbsolute(relative);
+}
+function readAnQstSettingsFromPath(cwd, settingsPath) {
+    if (!node_fs_1.default.existsSync(settingsPath)) {
+        throw new errors_1.VerifyError(`Missing AnQst settings file '${(0, layout_1.normalizeSlashes)(node_path_1.default.relative(cwd, settingsPath))}'. Run 'anqst instill <WidgetName>' first.`);
+    }
+    const raw = readJsonFile(settingsPath);
+    const settingsObject = ensureObject(raw, `Invalid AnQst settings file '${(0, layout_1.normalizeSlashes)(node_path_1.default.relative(cwd, settingsPath))}': expected JSON object.`);
+    const layoutVersion = settingsObject.layoutVersion;
+    if (layoutVersion !== layout_1.ANQST_LAYOUT_VERSION) {
+        throw new errors_1.VerifyError(`Invalid AnQst settings file '${(0, layout_1.normalizeSlashes)(node_path_1.default.relative(cwd, settingsPath))}': expected layoutVersion ${layout_1.ANQST_LAYOUT_VERSION}.`);
+    }
+    const widgetName = settingsObject.widgetName;
+    if (typeof widgetName !== "string" || widgetName.trim().length === 0) {
+        throw new errors_1.VerifyError(`Invalid AnQst settings file '${(0, layout_1.normalizeSlashes)(node_path_1.default.relative(cwd, settingsPath))}': expected non-empty string 'widgetName'.`);
+    }
+    const spec = settingsObject.spec;
+    if (typeof spec !== "string" || spec.trim().length === 0) {
+        throw new errors_1.VerifyError(`Invalid AnQst settings file '${(0, layout_1.normalizeSlashes)(node_path_1.default.relative(cwd, settingsPath))}': expected non-empty string 'spec'.`);
+    }
+    const generate = settingsObject.generate;
+    if (generate !== undefined && (!Array.isArray(generate) || generate.some((entry) => typeof entry !== "string"))) {
+        throw new errors_1.VerifyError(`Invalid AnQst settings file '${(0, layout_1.normalizeSlashes)(node_path_1.default.relative(cwd, settingsPath))}': expected string array 'generate'.`);
+    }
+    const widgetCategory = settingsObject.widgetCategory;
+    if (widgetCategory !== undefined) {
+        if (typeof widgetCategory !== "string" || widgetCategory.trim().length === 0) {
+            throw new errors_1.VerifyError(`Invalid AnQst settings file '${(0, layout_1.normalizeSlashes)(node_path_1.default.relative(cwd, settingsPath))}': expected non-empty string 'widgetCategory'.`);
+        }
+    }
+    const resolvedSpecPath = node_path_1.default.resolve(cwd, spec.trim());
+    const anqstRoot = (0, layout_1.anqstRootDir)(cwd);
+    if (!isSubPath(anqstRoot, resolvedSpecPath)) {
+        throw new errors_1.VerifyError(`Invalid AnQst settings file '${(0, layout_1.normalizeSlashes)(node_path_1.default.relative(cwd, settingsPath))}': 'spec' must resolve inside './AnQst'.`);
+    }
+    return {
+        layoutVersion,
+        widgetName: widgetName.trim(),
+        spec: spec.trim(),
+        generate: Array.isArray(generate) ? [...generate] : undefined,
+        widgetCategory: typeof widgetCategory === "string" ? widgetCategory.trim() : undefined
+    };
+}
+function resolveSettingsPathFromPackage(cwd, packageJson) {
+    const settingsRef = packageJson.AnQst;
+    if (settingsRef === undefined) {
+        throw new errors_1.VerifyError("Missing package.json key 'AnQst'. Run 'anqst instill <WidgetName>' first.");
+    }
+    if (typeof settingsRef !== "string" || settingsRef.trim().length === 0) {
+        throw new errors_1.VerifyError("Invalid package.json key 'AnQst': expected non-empty string path to settings JSON.");
+    }
+    return node_path_1.default.resolve(cwd, settingsRef.trim());
+}
+function buildAnQstDirectoryReadme(widgetName) {
+    return [
+        "# AnQst Project Directory",
+        "",
+        "This directory is owned by the AnQst CLI for this project.",
+        "",
+        "## Files",
+        "",
+        `- \`${(0, layout_1.anqstSpecFileName)(widgetName)}\`: AnQst widget spec source.`,
+        `- \`${(0, layout_1.anqstSettingsFileName)(widgetName)}\`: project-local AnQst configuration used by \`anqst build\`.`,
+        "- `generated/`: deterministic build output roots managed by `anqst build`.",
+        "",
+        "## Regeneration",
+        "",
+        "- `npx anqst build` refreshes generated outputs under `generated/`.",
+        "- Build hooks in package.json (`postinstall`, `prebuild`, `prestart`) call `npx anqst build`.",
+        "",
+        "Do not hand-edit generated files under `generated/`; they are overwritten by design.",
+        ""
+    ].join("\n");
+}
+function updateTsConfig(cwd, widgetName) {
+    const tsConfigPath = node_path_1.default.join(cwd, "tsconfig.json");
+    if (!node_fs_1.default.existsSync(tsConfigPath)) {
+        return;
+    }
+    const tsConfigRaw = readJsonFile(tsConfigPath);
+    const tsConfig = ensureObject(tsConfigRaw, "Invalid tsconfig.json: expected top-level object.");
+    const compilerOptions = tsConfig.compilerOptions === undefined
+        ? {}
+        : ensureObject(tsConfig.compilerOptions, "Invalid tsconfig.json: expected object at 'compilerOptions'.");
+    tsConfig.compilerOptions = compilerOptions;
+    if (compilerOptions.baseUrl === undefined) {
+        compilerOptions.baseUrl = ".";
+    }
+    const pathsObject = compilerOptions.paths === undefined
+        ? {}
+        : ensureObject(compilerOptions.paths, "Invalid tsconfig.json: expected object at 'compilerOptions.paths'.");
+    compilerOptions.paths = pathsObject;
+    const generatedAliasPath = `AnQst/generated/frontend/${(0, layout_1.generatedFrontendDirName)(widgetName)}/*`;
+    const existingAlias = pathsObject["anqst-generated/*"];
+    const aliasList = Array.isArray(existingAlias)
+        ? existingAlias.filter((entry) => typeof entry === "string")
+        : [];
+    if (!aliasList.includes(generatedAliasPath)) {
+        aliasList.unshift(generatedAliasPath);
+    }
+    pathsObject["anqst-generated/*"] = [...new Set(aliasList)];
+    if (Array.isArray(tsConfig.include)) {
+        const includeList = tsConfig.include.filter((entry) => typeof entry === "string");
+        const generatedTypesPattern = `AnQst/generated/frontend/${(0, layout_1.generatedFrontendDirName)(widgetName)}/**/*.d.ts`;
+        if (!includeList.includes(generatedTypesPattern)) {
+            includeList.push(generatedTypesPattern);
+        }
+        tsConfig.include = includeList;
+    }
+    node_fs_1.default.writeFileSync(tsConfigPath, `${JSON.stringify(tsConfig, null, 2)}\n`, "utf8");
+}
+function validateWidgetName(widgetName) {
+    const trimmed = widgetName.trim();
+    if (trimmed.length === 0) {
+        throw new errors_1.VerifyError("Usage: anqst instill <WidgetName>");
+    }
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(trimmed)) {
+        throw new errors_1.VerifyError("Invalid widget name: expected a TypeScript identifier for namespace generation.");
+    }
+    return trimmed;
 }
 function readProjectPackage(cwd) {
     const packagePath = node_path_1.default.join(cwd, "package.json");
     if (!node_fs_1.default.existsSync(packagePath)) {
-        throw new errors_1.VerifyError("No package.json: Can only instill AnQst inside an npm project.");
+        throw new errors_1.VerifyError("No package.json: AnQst commands must run inside an npm project.");
     }
     return {
         packagePath,
         packageJson: readJsonFile(packagePath)
     };
 }
-function resolveAnQstSpecPath(cwd) {
+function resolveAnQstSettings(cwd) {
     const { packageJson } = readProjectPackage(cwd);
-    const spec = packageJson.AnQst?.spec;
-    if (!spec || spec.trim().length === 0) {
-        throw new errors_1.VerifyError("Missing package.json key 'AnQst.spec'. Run 'anqst instill <WidgetName>' first.");
-    }
-    return node_path_1.default.resolve(cwd, spec);
+    const settingsPath = resolveSettingsPathFromPackage(cwd, packageJson);
+    return {
+        settingsPath,
+        settings: readAnQstSettingsFromPath(cwd, settingsPath)
+    };
+}
+function resolveAnQstSpecPath(cwd) {
+    const { settings } = resolveAnQstSettings(cwd);
+    return node_path_1.default.resolve(cwd, settings.spec);
 }
 function resolveAnQstGenerateTargets(cwd) {
-    const { packageJson } = readProjectPackage(cwd);
-    const configured = packageJson.AnQst?.generate;
-    if (configured === undefined) {
+    const { settings } = resolveAnQstSettings(cwd);
+    if (!settings.generate) {
         return [...exports.DEFAULT_ANQST_GENERATE_TARGETS];
     }
-    if (!Array.isArray(configured) || configured.some((value) => typeof value !== "string")) {
-        throw new errors_1.VerifyError("Invalid package.json key 'AnQst.generate': expected string array.");
-    }
-    return [...configured];
-}
-function loadDslSource() {
-    const candidates = [
-        node_path_1.default.resolve(__dirname, "../../spec/AnQst-Spec-DSL.d.ts"),
-        node_path_1.default.resolve(__dirname, "../../../spec/AnQst-Spec-DSL.d.ts")
-    ];
-    for (const filePath of candidates) {
-        if (node_fs_1.default.existsSync(filePath))
-            return node_fs_1.default.readFileSync(filePath, "utf8");
-    }
-    return `export namespace AnQst {
-  interface Service {}
-  interface Call<T> { dummy: T }
-  interface Slot<T> { dummy: T }
-  interface Emitter {}
-  interface Output<T> {}
-  interface Input<T> {}
-  enum Type {
-    string = "string",
-    number = "number",
-    qint64 = "qint64",
-    qint32 = "qint32"
-  }
-}`;
-}
-function installDslShim(cwd) {
-    const dslDir = node_path_1.default.join(cwd, "anqst-dsl");
-    node_fs_1.default.mkdirSync(dslDir, { recursive: true });
-    node_fs_1.default.writeFileSync(node_path_1.default.join(dslDir, "AnQst-Spec-DSL.d.ts"), loadDslSource(), "utf8");
+    return [...settings.generate];
+}
+function resolveAnQstWidgetCategory(cwd) {
+    const { settings } = resolveAnQstSettings(cwd);
+    return settings.widgetCategory;
+}
+function resolveAnQstWidgetName(cwd) {
+    const { settings } = resolveAnQstSettings(cwd);
+    return settings.widgetName;
 }
 function buildSpecScaffold(widgetName) {
-    return `import { AnQst } from "./anqst-dsl/AnQst-Spec-DSL";
-
-declare namespace ${widgetName} {
-
-}
+    return `${ANQST_DSL_IMPORT_LINE}
+
+` +
+        `declare namespace ${widgetName} {
+
+` +
+        `}
 `;
 }
 function runInstill(cwd, widgetName) {
-    if (!widgetName || widgetName.trim().length === 0) {
-        throw new errors_1.VerifyError("Usage: anqst instill <WidgetName>");
-    }
-    const cleanName = widgetName.trim();
+    const cleanName = validateWidgetName(widgetName);
     const { packagePath, packageJson } = readProjectPackage(cwd);
-    if (packageJson.AnQst) {
+    if (packageJson.AnQst !== undefined) {
         throw new errors_1.VerifyError("AnQst already instilled, did you mean to run 'npx anqst build'?");
     }
-    const next = {
+    const anqstRoot = (0, layout_1.anqstRootDir)(cwd);
+    node_fs_1.default.mkdirSync(anqstRoot, { recursive: true });
+    node_fs_1.default.mkdirSync(node_path_1.default.join(anqstRoot, "generated"), { recursive: true });
+    const specPath = node_path_1.default.join(anqstRoot, (0, layout_1.anqstSpecFileName)(cleanName));
+    if (node_fs_1.default.existsSync(specPath)) {
+        const existingText = node_fs_1.default.readFileSync(specPath, "utf8");
+        const normalizedImport = normalizeAnQstImport(existingText);
+        if (normalizedImport.changed) {
+            node_fs_1.default.writeFileSync(specPath, normalizedImport.nextText, "utf8");
+        }
+    }
+    else {
+        node_fs_1.default.writeFileSync(specPath, buildSpecScaffold(cleanName), "utf8");
+    }
+    const settingsPath = node_path_1.default.join(anqstRoot, (0, layout_1.anqstSettingsFileName)(cleanName));
+    const settings = {
+        layoutVersion: layout_1.ANQST_LAYOUT_VERSION,
+        widgetName: cleanName,
+        spec: `./AnQst/${(0, layout_1.anqstSpecFileName)(cleanName)}`,
+        generate: [...exports.DEFAULT_ANQST_GENERATE_TARGETS],
+        widgetCategory: "AnQst Widgets"
+    };
+    node_fs_1.default.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(anqstRoot, ".gitignore"), "/generated*\n", "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(anqstRoot, "README.md"), buildAnQstDirectoryReadme(cleanName), "utf8");
+    const nextPackage = {
         ...packageJson,
         scripts: {
-            ...packageJson.scripts,
-            build: prependScript(packageJson.scripts?.build, "npx anqst build"),
-            test: prependScript(packageJson.scripts?.test, "npx anqst test")
+            ...(packageJson.scripts ?? {}),
+            postinstall: ensureBuildHook(packageJson.scripts?.postinstall),
+            prebuild: ensureBuildHook(packageJson.scripts?.prebuild),
+            prestart: ensureBuildHook(packageJson.scripts?.prestart)
         },
-        AnQst: {
-            spec: `${cleanName}.AnQst.d.ts`,
-            generate: [...exports.DEFAULT_ANQST_GENERATE_TARGETS]
-        }
+        AnQst: (0, layout_1.anqstSettingsRelativePath)(cleanName)
     };
-    node_fs_1.default.writeFileSync(packagePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
-    const specPath = node_path_1.default.join(cwd, `${cleanName}.AnQst.d.ts`);
-    if (!node_fs_1.default.existsSync(specPath)) {
-        node_fs_1.default.writeFileSync(specPath, buildSpecScaffold(cleanName), "utf8");
-    }
-    installDslShim(cwd);
-    return `Instill completed: configured package.json and scaffolded ${cleanName}.AnQst.d.ts`;
+    node_fs_1.default.writeFileSync(packagePath, `${JSON.stringify(nextPackage, null, 2)}\n`, "utf8");
+    updateTsConfig(cwd, cleanName);
+    return `Instill completed: configured package.json and scaffolded ${(0, layout_1.normalizeSlashes)(node_path_1.default.relative(cwd, specPath))}`;
 }