@dusted/anqst 0.1.0

package/dist/src/errors.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerifyError = void 0;
+exports.formatVerifyError = formatVerifyError;
+const node_path_1 = __importDefault(require("node:path"));
+class VerifyError extends Error {
+    constructor(message, loc) {
+        super(message);
+        this.name = "VerifyError";
+        this.loc = loc;
+    }
+}
+exports.VerifyError = VerifyError;
+function formatVerifyError(error) {
+    const normalizeSlashes = (inputPath) => inputPath.split(node_path_1.default.sep).join("/");
+    const normalizedFile = normalizeSlashes(error.loc?.file ?? "<unknown>");
+    if (error.loc) {
+        return `\nAnQst spec invalid: ${normalizedFile}\n    ${normalizedFile}:${error.loc.line}:${error.loc.column} ${error.message}\n`;
+    }
+    return `\nAnQst spec invalid: ${normalizedFile}\n    ${error.message}\n`;
+}

package/dist/src/model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/parser.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSpecFile = parseSpecFile;
+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");
+function locFromNode(source, node) {
+    const lc = source.getLineAndCharacterOfPosition(node.getStart(source));
+    return {
+        file: source.fileName,
+        line: lc.line + 1,
+        column: lc.character + 1
+    };
+}
+function qNameToText(name) {
+    if (typescript_1.default.isIdentifier(name))
+        return name.text;
+    return `${qNameToText(name.left)}.${name.right.text}`;
+}
+function collectReferencedTypeNames(node) {
+    const refs = new Set();
+    const visit = (n) => {
+        if (typescript_1.default.isTypeReferenceNode(n)) {
+            refs.add(qNameToText(n.typeName));
+        }
+        else if (typescript_1.default.isExpressionWithTypeArguments(n) && typescript_1.default.isIdentifier(n.expression)) {
+            refs.add(n.expression.text);
+        }
+        typescript_1.default.forEachChild(n, visit);
+    };
+    visit(node);
+    return [...refs];
+}
+function parseTypeDecl(source, node) {
+    const name = node.name.text;
+    return {
+        name,
+        kind: typescript_1.default.isInterfaceDeclaration(node) ? "interface" : "type",
+        nodeText: node.getText(source),
+        referencedTypeNames: collectReferencedTypeNames(node),
+        loc: locFromNode(source, node)
+    };
+}
+function parseMemberKindFromAnQstType(typeNode) {
+    if (!typescript_1.default.isTypeReferenceNode(typeNode))
+        return null;
+    const typeName = qNameToText(typeNode.typeName);
+    if (!typeName.startsWith("AnQst."))
+        return null;
+    const kind = typeName.slice("AnQst.".length);
+    if (!["Call", "Slot", "Emitter", "Output", "Input"].includes(kind))
+        return null;
+    if (kind === "Emitter")
+        return { kind, payload: null };
+    const arg = typeNode.typeArguments?.[0];
+    return { kind, payload: arg ? arg.getText() : null };
+}
+function parseServiceMember(source, member) {
+    if (typescript_1.default.isMethodSignature(member)) {
+        if (member.questionToken)
+            throw new errors_1.VerifyError("Optional service methods are not allowed.", locFromNode(source, member));
+        const returnType = member.type;
+        if (!returnType)
+            throw new errors_1.VerifyError("Service method must declare return type.", locFromNode(source, member));
+        const parsed = parseMemberKindFromAnQstType(returnType);
+        if (!parsed)
+            throw new errors_1.VerifyError(`Unsupported service method return type '${returnType.getText()}'.`, locFromNode(source, member));
+        if (parsed.kind === "Input" || parsed.kind === "Output") {
+            throw new errors_1.VerifyError(`${parsed.kind} must be declared as property, not method.`, locFromNode(source, member));
+        }
+        if (!member.name || !typescript_1.default.isIdentifier(member.name)) {
+            throw new errors_1.VerifyError("Only identifier service method names are supported.", locFromNode(source, member));
+        }
+        const parameters = member.parameters.map((param) => {
+            if (param.dotDotDotToken)
+                throw new errors_1.VerifyError("Rest parameters are not allowed in service methods.", locFromNode(source, param));
+            if (!typescript_1.default.isIdentifier(param.name))
+                throw new errors_1.VerifyError("Only identifier parameter names are supported.", locFromNode(source, param));
+            if (!param.type)
+                throw new errors_1.VerifyError("Service parameters must declare type.", locFromNode(source, param));
+            return { name: param.name.text, typeText: param.type.getText() };
+        });
+        return {
+            kind: parsed.kind,
+            name: member.name.text,
+            payloadTypeText: parsed.payload,
+            parameters,
+            loc: locFromNode(source, member)
+        };
+    }
+    if (typescript_1.default.isPropertySignature(member)) {
+        if (!member.type)
+            throw new errors_1.VerifyError("Service property must declare type.", locFromNode(source, member));
+        if (member.questionToken)
+            throw new errors_1.VerifyError("Optional service properties are not allowed.", locFromNode(source, member));
+        const parsed = parseMemberKindFromAnQstType(member.type);
+        if (!parsed)
+            throw new errors_1.VerifyError(`Unsupported service property type '${member.type.getText()}'.`, locFromNode(source, member));
+        if (parsed.kind !== "Input" && parsed.kind !== "Output") {
+            throw new errors_1.VerifyError(`${parsed.kind} must be declared as method, not property.`, locFromNode(source, member));
+        }
+        if (!member.name || !typescript_1.default.isIdentifier(member.name)) {
+            throw new errors_1.VerifyError("Only identifier service property names are supported.", locFromNode(source, member));
+        }
+        return {
+            kind: parsed.kind,
+            name: member.name.text,
+            payloadTypeText: parsed.payload,
+            parameters: [],
+            loc: locFromNode(source, member)
+        };
+    }
+    throw new errors_1.VerifyError("Unsupported service member declaration.", locFromNode(source, member));
+}
+function tryResolveImportFile(specFilePath, moduleName) {
+    const baseDir = node_path_1.default.dirname(specFilePath);
+    const candidates = [];
+    const pushCandidates = (p) => {
+        candidates.push(p, `${p}.d.ts`, `${p}.ts`, node_path_1.default.join(p, "index.d.ts"), node_path_1.default.join(p, "index.ts"));
+    };
+    if (moduleName.startsWith(".") || moduleName.startsWith("/")) {
+        pushCandidates(node_path_1.default.resolve(baseDir, moduleName));
+    }
+    else {
+        // Support path-like bare spec imports (e.g. types/exchange) relative to spec file dir.
+        pushCandidates(node_path_1.default.resolve(baseDir, moduleName));
+    }
+    for (const candidate of candidates) {
+        if (node_fs_1.default.existsSync(candidate) && node_fs_1.default.statSync(candidate).isFile())
+            return candidate;
+    }
+    return null;
+}
+function requiresLocalImportResolution(moduleName) {
+    if (moduleName.startsWith(".") || moduleName.startsWith("/"))
+        return true;
+    if (moduleName.startsWith("@"))
+        return false;
+    return moduleName.includes("/");
+}
+function parseImportedTypeDecls(specFilePath, source) {
+    const importedTypeDecls = new Map();
+    const importedTypeSymbols = new Set();
+    const specImports = [];
+    for (const stmt of source.statements) {
+        if (!typescript_1.default.isImportDeclaration(stmt) || !stmt.importClause || !typescript_1.default.isStringLiteral(stmt.moduleSpecifier))
+            continue;
+        const moduleName = stmt.moduleSpecifier.text;
+        const importModel = {
+            moduleSpecifier: moduleName,
+            defaultImport: null,
+            namedImports: []
+        };
+        if (stmt.importClause.name) {
+            importedTypeSymbols.add(stmt.importClause.name.text);
+            importModel.defaultImport = stmt.importClause.name.text;
+        }
+        const bindings = stmt.importClause.namedBindings;
+        if (bindings && typescript_1.default.isNamedImports(bindings)) {
+            for (const el of bindings.elements) {
+                importedTypeSymbols.add((el.propertyName ?? el.name).text);
+                importedTypeSymbols.add(el.name.text);
+                importModel.namedImports.push({
+                    importedName: (el.propertyName ?? el.name).text,
+                    localName: el.name.text
+                });
+            }
+        }
+        else if (bindings && typescript_1.default.isNamespaceImport(bindings)) {
+            throw new errors_1.VerifyError("Namespace imports ('import * as X') are not allowed in AnQst spec files.", locFromNode(source, bindings));
+        }
+        specImports.push(importModel);
+        const resolved = tryResolveImportFile(specFilePath, moduleName);
+        if (!resolved) {
+            if (requiresLocalImportResolution(moduleName)) {
+                throw new errors_1.VerifyError(`Unable to resolve import '${moduleName}' from spec file.`, locFromNode(source, stmt.moduleSpecifier));
+            }
+            continue;
+        }
+        const text = node_fs_1.default.readFileSync(resolved, "utf8");
+        const importedSource = typescript_1.default.createSourceFile(resolved, text, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
+        for (const importedStmt of importedSource.statements) {
+            if (typescript_1.default.isInterfaceDeclaration(importedStmt) || typescript_1.default.isTypeAliasDeclaration(importedStmt)) {
+                const decl = parseTypeDecl(importedSource, importedStmt);
+                importedTypeDecls.set(decl.name, decl);
+            }
+        }
+    }
+    return { importedTypeDecls, importedTypeSymbols, specImports };
+}
+function serviceBaseType(iface) {
+    if (!iface.heritageClauses)
+        return null;
+    for (const clause of iface.heritageClauses) {
+        if (clause.token !== typescript_1.default.SyntaxKind.ExtendsKeyword)
+            continue;
+        for (const t of clause.types) {
+            if (t.expression.getText() === "AnQst.Service")
+                return "Service";
+            if (t.expression.getText() === "AnQst.AngularHTTPBaseServerClass")
+                return "AngularHTTPBaseServerClass";
+        }
+    }
+    return null;
+}
+function parseSpecFile(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");
+    const source = typescript_1.default.createSourceFile(specFilePath, text, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
+    const namespaces = source.statements.filter((s) => typescript_1.default.isModuleDeclaration(s));
+    if (namespaces.length !== 1)
+        throw new errors_1.VerifyError("Spec must declare exactly one top-level namespace.");
+    const ns = namespaces[0];
+    if (!typescript_1.default.isIdentifier(ns.name))
+        throw new errors_1.VerifyError("Namespace name must be an identifier.", locFromNode(source, ns));
+    const hasDeclare = !!ns.modifiers?.some((m) => m.kind === typescript_1.default.SyntaxKind.DeclareKeyword);
+    if (!hasDeclare)
+        throw new errors_1.VerifyError("Top-level namespace must be declared with 'declare namespace'.", locFromNode(source, ns));
+    if (!ns.body || !typescript_1.default.isModuleBlock(ns.body))
+        throw new errors_1.VerifyError("Namespace body must be a block.", locFromNode(source, ns));
+    const services = [];
+    const namespaceTypeDecls = [];
+    let supportsDevelopmentModeTransport = false;
+    for (const stmt of ns.body.statements) {
+        if (typescript_1.default.isInterfaceDeclaration(stmt)) {
+            const baseType = serviceBaseType(stmt);
+            if (baseType !== null) {
+                const members = stmt.members.map((member) => parseServiceMember(source, member));
+                if (baseType === "AngularHTTPBaseServerClass") {
+                    supportsDevelopmentModeTransport = true;
+                }
+                services.push({ name: stmt.name.text, baseType, members, loc: locFromNode(source, stmt) });
+            }
+            else {
+                namespaceTypeDecls.push(parseTypeDecl(source, stmt));
+            }
+            continue;
+        }
+        if (typescript_1.default.isTypeAliasDeclaration(stmt)) {
+            namespaceTypeDecls.push(parseTypeDecl(source, stmt));
+        }
+    }
+    const importInfo = parseImportedTypeDecls(specFilePath, source);
+    return {
+        filePath: specFilePath,
+        widgetName: ns.name.text,
+        services,
+        supportsDevelopmentModeTransport,
+        namespaceTypeDecls,
+        importedTypeDecls: importInfo.importedTypeDecls,
+        importedTypeSymbols: importInfo.importedTypeSymbols,
+        specImports: importInfo.specImports
+    };
+}

package/dist/src/project.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ANQST_GENERATE_TARGETS = void 0;
+exports.readProjectPackage = readProjectPackage;
+exports.resolveAnQstSpecPath = resolveAnQstSpecPath;
+exports.resolveAnQstGenerateTargets = resolveAnQstGenerateTargets;
+exports.installDslShim = installDslShim;
+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"];
+function readJsonFile(filePath) {
+    const raw = node_fs_1.default.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+}
+function prependScript(existing, prefix) {
+    if (!existing || existing.trim().length === 0)
+        return prefix;
+    const trimmed = existing.trim();
+    if (trimmed === prefix || trimmed.startsWith(`${prefix} &&`))
+        return trimmed;
+    return `${prefix} && ${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.");
+    }
+    return {
+        packagePath,
+        packageJson: readJsonFile(packagePath)
+    };
+}
+function resolveAnQstSpecPath(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);
+}
+function resolveAnQstGenerateTargets(cwd) {
+    const { packageJson } = readProjectPackage(cwd);
+    const configured = packageJson.AnQst?.generate;
+    if (configured === undefined) {
+        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");
+}
+function buildSpecScaffold(widgetName) {
+    return `import { AnQst } from "./anqst-dsl/AnQst-Spec-DSL";
+
+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 { packagePath, packageJson } = readProjectPackage(cwd);
+    if (packageJson.AnQst) {
+        throw new errors_1.VerifyError("AnQst already instilled, did you mean to run 'npx anqst build'?");
+    }
+    const next = {
+        ...packageJson,
+        scripts: {
+            ...packageJson.scripts,
+            build: prependScript(packageJson.scripts?.build, "npx anqst build"),
+            test: prependScript(packageJson.scripts?.test, "npx anqst test")
+        },
+        AnQst: {
+            spec: `${cleanName}.AnQst.d.ts`,
+            generate: [...exports.DEFAULT_ANQST_GENERATE_TARGETS]
+        }
+    };
+    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`;
+}

package/dist/src/verify.js

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySpec = verifySpec;
+const typescript_1 = __importDefault(require("typescript"));
+const errors_1 = require("./errors");
+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 errors_1.VerifyError(`Unable to parse type: ${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 checkForbiddenTypeNodes(typeNode) {
+    let forbidden = null;
+    const visit = (node) => {
+        if (forbidden)
+            return;
+        if (node.kind === typescript_1.default.SyntaxKind.AnyKeyword)
+            forbidden = "any";
+        else if (node.kind === typescript_1.default.SyntaxKind.UnknownKeyword)
+            forbidden = "unknown";
+        else if (node.kind === typescript_1.default.SyntaxKind.NeverKeyword)
+            forbidden = "never";
+        else if (node.kind === typescript_1.default.SyntaxKind.SymbolKeyword)
+            forbidden = "symbol";
+        else if (typescript_1.default.isFunctionTypeNode(node))
+            forbidden = "function type";
+        else if (typescript_1.default.isTypeReferenceNode(node) && qNameText(node.typeName) === "Promise")
+            forbidden = "Promise";
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(typeNode);
+    return forbidden;
+}
+function checkServiceMember(member) {
+    if (member.payloadTypeText && member.kind === "Call") {
+        const payload = parseTypeNodeFromText(member.payloadTypeText);
+        const refs = typeRefs(payload);
+        if (refs.includes("Promise")) {
+            throw new errors_1.VerifyError(`Promise is not allowed inside ${member.kind}<T> payload for '${member.name}'.`, member.loc);
+        }
+    }
+    if (member.payloadTypeText) {
+        const node = parseTypeNodeFromText(member.payloadTypeText);
+        const forbidden = checkForbiddenTypeNodes(node);
+        if (forbidden) {
+            throw new errors_1.VerifyError(`Forbidden type '${forbidden}' in payload of '${member.name}'.`, member.loc);
+        }
+    }
+    for (const parameter of member.parameters) {
+        const node = parseTypeNodeFromText(parameter.typeText);
+        const forbidden = checkForbiddenTypeNodes(node);
+        if (forbidden) {
+            throw new errors_1.VerifyError(`Forbidden type '${forbidden}' in parameter '${parameter.name}' of '${member.name}'.`, member.loc);
+        }
+    }
+}
+function checkServiceDuplicates(spec) {
+    const globalMemberToService = new Map();
+    for (const service of spec.services) {
+        const byName = new Map();
+        for (const member of service.members) {
+            const list = byName.get(member.name) ?? [];
+            list.push(member);
+            byName.set(member.name, list);
+            const ownerService = globalMemberToService.get(member.name);
+            if (ownerService && ownerService !== service.name) {
+                throw new errors_1.VerifyError(`Duplicate member name '${member.name}' across services ('${ownerService}' and '${service.name}') is invalid.`, member.loc);
+            }
+            if (!ownerService) {
+                globalMemberToService.set(member.name, service.name);
+            }
+        }
+        for (const [name, list] of byName) {
+            if (list.length > 1) {
+                throw new errors_1.VerifyError(`Duplicate method signature '${name}' is invalid.`, list[1].loc);
+            }
+        }
+    }
+}
+function isBuiltinOrLiteral(ref) {
+    return [
+        "string",
+        "number",
+        "boolean",
+        "void",
+        "object",
+        "bigint",
+        "BigInt",
+        "Array",
+        "Record",
+        "Partial",
+        "Readonly",
+        "Date"
+    ].includes(ref);
+}
+function resolveRefsOrThrow(spec, refs, ctxLoc, context) {
+    const local = new Set(spec.namespaceTypeDecls.map((d) => d.name));
+    const imported = spec.importedTypeDecls;
+    for (const ref of refs) {
+        if (isBuiltinOrLiteral(ref))
+            continue;
+        if (ref.startsWith("AnQst."))
+            continue;
+        if (local.has(ref))
+            continue;
+        if (imported.has(ref))
+            continue;
+        const namespacePrefix = ref.split(".")[0];
+        if (spec.importedTypeSymbols.has(namespacePrefix))
+            continue;
+        throw new errors_1.VerifyError(`Unresolved type reference '${ref}' in ${context}.`, ctxLoc);
+    }
+}
+function collectReachableTypeNames(spec) {
+    const allDecls = new Map();
+    for (const d of spec.namespaceTypeDecls)
+        allDecls.set(d.name, d);
+    for (const [name, d] of spec.importedTypeDecls)
+        allDecls.set(name, d);
+    const queue = [];
+    const seen = new Set();
+    for (const d of spec.namespaceTypeDecls)
+        queue.push(d.name);
+    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) {
+                const refs = typeRefs(parseTypeNodeFromText(typeText));
+                for (const ref of refs) {
+                    if (!isBuiltinOrLiteral(ref) && !ref.startsWith("AnQst."))
+                        queue.push(ref);
+                }
+            }
+        }
+    }
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        if (seen.has(cur))
+            continue;
+        seen.add(cur);
+        const decl = allDecls.get(cur);
+        if (!decl)
+            continue;
+        for (const ref of decl.referencedTypeNames) {
+            if (!isBuiltinOrLiteral(ref) && !ref.startsWith("AnQst.") && !seen.has(ref)) {
+                queue.push(ref);
+            }
+        }
+    }
+    return seen;
+}
+function verifySpec(spec) {
+    checkServiceDuplicates(spec);
+    for (const service of spec.services) {
+        for (const member of service.members) {
+            checkServiceMember(member);
+            const texts = [...member.parameters.map((p) => p.typeText)];
+            if (member.payloadTypeText)
+                texts.push(member.payloadTypeText);
+            for (const typeText of texts) {
+                const refs = typeRefs(parseTypeNodeFromText(typeText));
+                resolveRefsOrThrow(spec, refs, member.loc, `service member '${member.name}'`);
+            }
+        }
+    }
+    for (const decl of spec.namespaceTypeDecls) {
+        resolveRefsOrThrow(spec, decl.referencedTypeNames, decl.loc, `type declaration '${decl.name}'`);
+    }
+    const reachable = collectReachableTypeNames(spec);
+    const stats = {
+        namespaceDeclaredTypes: spec.namespaceTypeDecls.length,
+        reachableGeneratedTypes: reachable.size,
+        serviceCount: spec.services.length
+    };
+    return {
+        stats,
+        message: `AnQst spec valid:\n    ${stats.namespaceDeclaredTypes} types.\n    ${stats.serviceCount} services.`
+    };
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@dusted/anqst",
+  "version": "0.1.0",
+  "description": "Opinionated backend generator for webapps.",
+  "keywords": [
+    "nodejs",
+    "qt",
+    "angular",
+    "webapp"
+  ],
+  "homepage": "https://github.com/DusteDdk/AnQst#readme",
+  "bugs": {
+    "url": "https://github.com/DusteDdk/AnQst/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DusteDdk/AnQst.git",
+    "directory": "AnQstGen"
+  },
+  "license": "WTFPL",
+  "author": "DusteD",
+  "type": "commonjs",
+  "main": "dist/src/app.js",
+  "exports": {
+    ".": "./dist/src/app.js"
+  },
+  "bin": {
+    "anqst": "dist/src/bin/anqst.js"
+  },
+  "files": [
+    "dist/src",
+    "spec/AnQst-Spec-DSL.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "build:test": "npm run clean && tsc -p tsconfig.json",
+    "prepare": "npm run build",
+    "test": "npm run build:test && node --test dist/test/**/*.test.js",
+    "start": "node dist/src/bin/anqst.js"
+  },
+  "dependencies": {
+    "typescript": "^5.9.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0"
+  }
+}