@dusted/anqst 1.6.0 → 1.7.0

package/dist/src/app.js

@@ -25,6 +25,14 @@ class CliUsageError extends Error {
         this.name = "CliUsageError";
     }
 }
+function firstBrowserFrontendTarget(targets) {
+    for (const target of targets) {
+        if (target === "AngularService" || target === "VanillaTS" || target === "VanillaJS") {
+            return target;
+        }
+    }
+    return null;
+}
 const ANQSTGEN_ACTIVE_STAMP_FILE = ".anqstgen-version-active.json";
 function renderHelp() {
     const version = readActiveBuildStamp();
@@ -219,7 +227,9 @@ function runBuild(cwd, designerPlugin = false) {
     try {
         const specPath = (0, project_1.resolveAnQstSpecPath)(cwd);
         const configuredWidgetName = (0, project_1.resolveAnQstWidgetName)(cwd);
+        const configuredTargets = (0, project_1.resolveAnQstGenerateTargets)(cwd);
         const generationTargets = resolveGenerationTargetsFromCwd(cwd, true);
+        const preferredFrontendTarget = firstBrowserFrontendTarget(configuredTargets);
         const parsed = (0, parser_1.parseSpecFile)(specPath);
         (0, verify_1.verifySpec)(parsed);
         if (parsed.widgetName !== configuredWidgetName) {
@@ -231,7 +241,9 @@ function runBuild(cwd, designerPlugin = false) {
         if (generationTargets.emitQWidget) {
             (0, emit_1.installQtIntegrationCMake)(cwd, parsed.widgetName);
         }
-        const shouldRunAngularBuild = generationTargets.emitQWidget && node_fs_1.default.existsSync(node_path_1.default.join(cwd, "angular.json"));
+        const shouldRunAngularBuild = generationTargets.emitQWidget
+            && preferredFrontendTarget === "AngularService"
+            && node_fs_1.default.existsSync(node_path_1.default.join(cwd, "angular.json"));
         if (shouldRunAngularBuild) {
             const angularBuild = (0, node_child_process_1.spawnSync)("npx", ["ng", "build", "--configuration", "production"], {
                 cwd,
@@ -242,8 +254,25 @@ function runBuild(cwd, designerPlugin = false) {
                 throw new errors_1.VerifyError("Angular build failed while preparing embedded widget assets.");
             }
         }
+        let embeddedAssetsRefreshed = false;
         if (generationTargets.emitQWidget) {
+            if (preferredFrontendTarget === "VanillaJS") {
+                try {
+                    (0, emit_1.buildVanillaJsBrowserBundle)(cwd, parsed.widgetName);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    throw new errors_1.VerifyError(`VanillaJS browser packaging failed: ${message}`);
+                }
+            }
             const embedded = (0, emit_1.installEmbeddedWebBundle)(cwd, parsed.widgetName);
+            embeddedAssetsRefreshed = embedded;
+            if (preferredFrontendTarget === "VanillaJS" && !embedded) {
+                throw new errors_1.VerifyError("Unable to embed VanillaJS browser output. Ensure src/index.html and src/main.js produced a browser bundle.");
+            }
+            if (preferredFrontendTarget === "VanillaTS" && !embedded) {
+                throw new errors_1.VerifyError("Unable to embed VanillaTS browser output. Ensure the widget frontend build produced dist/browser with index.html.");
+            }
             if (shouldRunAngularBuild && !embedded) {
                 throw new errors_1.VerifyError("Unable to embed browser output. Ensure the browser build produced a dist bundle with index.html.");
             }
@@ -284,19 +313,21 @@ function runBuild(cwd, designerPlugin = false) {
         if (generationTargets.emitVanillaTS) {
             detailLines.push("    Target VanillaTS:");
             detailLines.push(`      - Browser bundle root: ${(0, layout_1.toProjectRelative)(cwd, layout.vanillaTsFrontendRoot)}`);
-            detailLines.push(`      - Browser global: window.AnQstGenerated.widgets.${parsed.widgetName}`);
+            detailLines.push(`      - Browser global: window.AnQstGenerated.${parsed.widgetName}`);
         }
         if (generationTargets.emitVanillaJS) {
             detailLines.push("    Target VanillaJS:");
             detailLines.push(`      - Browser bundle root: ${(0, layout_1.toProjectRelative)(cwd, layout.vanillaJsFrontendRoot)}`);
-            detailLines.push(`      - Browser global: window.AnQstGenerated.widgets.${parsed.widgetName}`);
+            detailLines.push(`      - Browser global: window.AnQstGenerated.${parsed.widgetName}`);
         }
         if (generationTargets.emitQWidget) {
             detailLines.push("    Target QWidget:");
             detailLines.push(`      - Qt integration CMake: ${(0, layout_1.toProjectRelative)(cwd, node_path_1.default.join(layout.cppCmakeRoot, "CMakeLists.txt"))}`);
             detailLines.push(`      - Widget output root: ${(0, layout_1.toProjectRelative)(cwd, layout.cppQtWidgetRoot)}`);
             detailLines.push("      - C++ handoff: downstream CMake consumes this generated tree directly");
-            detailLines.push("      - Embedded web assets refreshed from detected browser dist output");
+            if (embeddedAssetsRefreshed) {
+                detailLines.push("      - Embedded web assets refreshed from detected browser dist output");
+            }
         }
         if (generationTargets.emitNodeExpressWs) {
             detailLines.push("    Target node_express_ws:");

package/dist/src/boundary-codec-analysis.js

@@ -128,8 +128,10 @@ class BoundaryTransportAnalyzer {
         const out = new Map();
         for (const decl of this.spec.namespaceTypeDecls)
             out.set(decl.name, decl);
-        for (const decl of this.spec.importedTypeDecls.values())
-            out.set(decl.name, decl);
+        for (const decl of this.spec.importedTypeDecls.values()) {
+            if (!out.has(decl.name))
+                out.set(decl.name, decl);
+        }
         return [...out.values()];
     }
     nodeMeta(typeText, path, identityParts) {

package/dist/src/emit.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateOutputs = generateOutputs;
 exports.writeGeneratedOutputs = writeGeneratedOutputs;
+exports.buildVanillaJsBrowserBundle = buildVanillaJsBrowserBundle;
 exports.installEmbeddedWebBundle = installEmbeddedWebBundle;
 exports.installQtIntegrationCMake = installQtIntegrationCMake;
 exports.installQtDesignerPluginCMake = installQtDesignerPluginCMake;
@@ -461,8 +462,10 @@ function collectStructDecls(spec) {
     const out = new Map();
     for (const d of spec.namespaceTypeDecls)
         out.set(d.name, d);
-    for (const d of spec.importedTypeDecls.values())
-        out.set(d.name, d);
+    for (const d of spec.importedTypeDecls.values()) {
+        if (!out.has(d.name))
+            out.set(d.name, d);
+    }
     return [...out.values()];
 }
 function mapTypeTextToTs(typeText) {
@@ -574,14 +577,18 @@ function normalizeImportPathForGenerated(specFilePath, generatedFileRelPath, mod
         return normalized;
     return `./${normalized}`;
 }
-function renderRequiredTypeImports(spec, generatedFileRelPath) {
+function renderRequiredTypeImports(spec, generatedFileRelPath, omitSymbols = new Set()) {
     const requiredSymbols = collectRequiredImportedSymbols(spec);
     if (requiredSymbols.size === 0)
         return "";
     const importLines = [];
     for (const imp of spec.specImports) {
-        const defaultImport = imp.defaultImport && requiredSymbols.has(imp.defaultImport) ? imp.defaultImport : null;
-        const named = imp.namedImports.filter((n) => requiredSymbols.has(n.localName));
+        const defaultImport = imp.defaultImport
+            && requiredSymbols.has(imp.defaultImport)
+            && !omitSymbols.has(imp.defaultImport)
+            ? imp.defaultImport
+            : null;
+        const named = imp.namedImports.filter((n) => requiredSymbols.has(n.localName) && !omitSymbols.has(n.localName));
         if (!defaultImport && named.length === 0)
             continue;
         const moduleSpecifier = normalizeImportPathForGenerated(spec.filePath, generatedFileRelPath, imp.moduleSpecifier);
@@ -3370,19 +3377,132 @@ ${constructorLines.join("\n")}${formatTsServiceSetAndOnSlotObjectLiterals(setMem
 }
 `;
 }
-function renderVanillaBrowserTs(spec, codecCatalog) {
+function collectVanillaValueClasses(spec) {
+    const classes = [];
+    const requiredImportedSymbols = collectRequiredImportedSymbols(spec);
+    const candidateDecls = [
+        ...spec.namespaceTypeDecls,
+        ...[...spec.importedTypeDecls.values()].filter((decl) => requiredImportedSymbols.has(decl.name))
+    ];
+    for (const decl of candidateDecls) {
+        if (decl.kind !== "interface")
+            continue;
+        const node = parseTypeDeclNode(decl.nodeText);
+        if (!node || !typescript_1.default.isInterfaceDeclaration(node))
+            continue;
+        const fields = [];
+        let supported = true;
+        for (const member of node.members) {
+            if (!typescript_1.default.isPropertySignature(member) || !member.type || !member.name || !typescript_1.default.isIdentifier(member.name)) {
+                supported = false;
+                break;
+            }
+            fields.push({
+                name: member.name.text,
+                typeText: member.type.getText(),
+                optional: !!member.questionToken
+            });
+        }
+        if (supported) {
+            classes.push({
+                name: decl.name,
+                fields
+            });
+        }
+    }
+    return classes;
+}
+function renderVanillaValueClassConstructorArgs(fields) {
+    let lastRequiredIndex = -1;
+    for (let i = 0; i < fields.length; i += 1) {
+        if (!fields[i].optional) {
+            lastRequiredIndex = i;
+        }
+    }
+    return fields.map((field, index) => {
+        const tsType = mapTypeTextToTs(field.typeText);
+        if (!field.optional) {
+            return `${field.name}: ${tsType}`;
+        }
+        if (index > lastRequiredIndex) {
+            return `${field.name}?: ${tsType}`;
+        }
+        return `${field.name}: ${tsType} | undefined`;
+    }).join(", ");
+}
+function renderVanillaValueClassTs(model) {
+    const fieldLines = model.fields.map((field) => {
+        const tsType = mapTypeTextToTs(field.typeText);
+        return field.optional
+            ? `  ${field.name}?: ${tsType};`
+            : `  ${field.name}: ${tsType};`;
+    });
+    const constructorArgs = renderVanillaValueClassConstructorArgs(model.fields);
+    const constructorBody = model.fields.map((field) => `    this.${field.name} = ${field.name};`);
+    const constructorLines = [
+        `  constructor(${constructorArgs}) {`,
+        ...constructorBody,
+        "  }"
+    ];
+    return `class ${model.name} {
+${fieldLines.join("\n")}
+
+${constructorLines.join("\n")}
+}`;
+}
+function renderVanillaValueClassDts(model) {
+    const fieldLines = model.fields.map((field) => {
+        const tsType = mapTypeTextToTs(field.typeText);
+        return field.optional
+            ? `  ${field.name}?: ${tsType};`
+            : `  ${field.name}: ${tsType};`;
+    });
+    const constructorArgs = renderVanillaValueClassConstructorArgs(model.fields);
+    return `interface ${model.name} {
+${fieldLines.join("\n")}
+}
+
+declare const ${model.name}: {
+  new (${constructorArgs}): ${model.name};
+  prototype: ${model.name};
+};`;
+}
+function renderVanillaBrowserTs(spec, codecCatalog, emitExports = false) {
     const localTypeDecls = renderTypeDeclarations(spec).trim();
     const localTypesBlock = localTypeDecls.length > 0 ? `${localTypeDecls}\n\n` : "";
+    const valueClasses = collectVanillaValueClasses(spec);
+    const valueClassDecls = valueClasses.map((model) => renderVanillaValueClassTs(model)).join("\n\n");
+    const valueClassBlock = valueClassDecls.length > 0 ? `${valueClassDecls}\n\n` : "";
     const dragDropHelperBlock = renderTsDragDropPayloadHelpers(spec, codecCatalog).trim();
     const dragDropHelpers = dragDropHelperBlock.length > 0 ? `\n// Drag/drop payload helpers\n${dragDropHelperBlock}\n` : "";
     const serviceClasses = spec.services.map((s) => renderVanillaServiceTs(spec, s.name, codecCatalog)).join("\n");
-    const frontendServices = spec.services.length > 0
-        ? spec.services.map((s) => `  ${s.name}: ${s.name};`).join("\n")
-        : "";
-    const frontendServiceFactories = spec.services.length > 0
-        ? spec.services.map((s) => `      ${s.name}: new ${s.name}(bridge)`).join(",\n")
+    const frontendShapeLines = [
+        "  diagnostics: AnQstBridgeDiagnostics;",
+        ...spec.services.map((s) => `  ${s.name}: ${s.name};`),
+        ...valueClasses.map((model) => `  ${model.name}: typeof ${model.name};`)
+    ];
+    const frontendFactoryLines = [
+        "    diagnostics: new AnQstBridgeDiagnostics(bridge)",
+        ...spec.services.map((s) => `    ${s.name}: new ${s.name}(bridge)`),
+        ...valueClasses.map((model) => `    ${model.name}`)
+    ];
+    const exportedRuntimeSymbols = [
+        "AnQstBridgeDiagnostics",
+        ...spec.services.map((s) => s.name),
+        ...valueClasses.map((model) => model.name),
+        "createFrontend"
+    ];
+    const exportedTypeSymbols = [
+        "AnQstBridgeDiagnostic",
+        "AnQstBridgeState",
+        `${spec.widgetName}Frontend`,
+        `${spec.widgetName}Global`,
+        "AnQstGeneratedRoot"
+    ];
+    const exportsBlock = emitExports
+        ? `\nexport { ${exportedRuntimeSymbols.join(", ")} };\nexport type { ${exportedTypeSymbols.join(", ")} };\n`
         : "";
-    return `${localTypesBlock}// Boundary codec plan helpers
+    return `${localTypesBlock}${valueClassBlock}// Boundary codec plan helpers
 ${(0, boundary_codecs_1.renderTsBoundaryCodecHelpers)(codecCatalog)}
 ${dragDropHelpers}
 
@@ -4200,34 +4320,25 @@ class AnQstBridgeDiagnostics {
 }
 
 ${serviceClasses}
-interface ${spec.widgetName}FrontendServices {
-${frontendServices}
-}
-
 interface ${spec.widgetName}Frontend {
-  diagnostics: AnQstBridgeDiagnostics;
-  services: ${spec.widgetName}FrontendServices;
+${frontendShapeLines.join("\n")}
 }
 
 async function createFrontend(): Promise<${spec.widgetName}Frontend> {
   const bridge = new AnQstBridgeRuntime();
   await bridge.ready();
   return {
-    diagnostics: new AnQstBridgeDiagnostics(bridge),
-    services: {
-${frontendServiceFactories}
-    }
+${frontendFactoryLines.join(",\n")}
   };
 }
 
-(function bootstrapAnQstGenerated(global: typeof globalThis & { AnQstGenerated?: { widgets?: Record<string, unknown> } }) {
+(function bootstrapAnQstGenerated(global: typeof globalThis & { AnQstGenerated?: Record<string, unknown> }) {
   const root = global.AnQstGenerated ?? (global.AnQstGenerated = {});
-  const widgets = root.widgets ?? (root.widgets = {});
-  widgets["${spec.widgetName}"] = {
+  root["${spec.widgetName}"] = {
     createFrontend
   };
-})(window as typeof globalThis & { AnQstGenerated?: { widgets?: Record<string, unknown> } });
-`;
+})(window as typeof globalThis & { AnQstGenerated?: Record<string, unknown> });
+${exportsBlock}`;
 }
 function renderVanillaServiceDts(spec, serviceName) {
     const members = spec.services.find((s) => s.name === serviceName)?.members ?? [];
@@ -4289,16 +4400,34 @@ ${declareBodyLines.join("\n")}
 }`;
 }
 function renderVanillaIndexDts(spec) {
-    const externalTypeImports = renderRequiredTypeImports(spec, `frontend/${(0, layout_1.generatedFrontendDirName)(spec.widgetName, "VanillaTS")}/index.d.ts`).trim();
+    const valueClasses = collectVanillaValueClasses(spec);
+    const valueClassNames = new Set(valueClasses.map((model) => model.name));
+    const externalTypeImports = renderRequiredTypeImports(spec, `frontend/${(0, layout_1.generatedFrontendDirName)(spec.widgetName, "VanillaTS")}/index.d.ts`, valueClassNames).trim();
     // Export widget namespace types so other packages can `import type { ... }` from this declaration file
     // (e.g. a second widget spec that reuses structs generated for the first widget).
     const localTypeDecls = renderTypeDeclarations(spec, true).trim();
+    const valueClassDecls = valueClasses.map((model) => renderVanillaValueClassDts(model)).join("\n\n");
     const serviceDecls = spec.services.map((s) => renderVanillaServiceDts(spec, s.name)).join("\n\n");
-    const servicesShape = spec.services.length > 0
-        ? spec.services.map((s) => `  ${s.name}: ${s.name};`).join("\n")
-        : "";
-    const sections = [externalTypeImports, localTypeDecls].filter((s) => s.length > 0);
+    const frontendShapeLines = [
+        "  diagnostics: AnQstBridgeDiagnostics;",
+        ...spec.services.map((s) => `  ${s.name}: ${s.name};`),
+        ...valueClasses.map((model) => `  ${model.name}: typeof ${model.name};`)
+    ];
+    const sections = [externalTypeImports, localTypeDecls, valueClassDecls].filter((s) => s.length > 0);
     const prelude = sections.length > 0 ? `${sections.join("\n\n")}\n\n` : "";
+    const exportedRuntimeSymbols = [
+        "AnQstBridgeDiagnostics",
+        ...spec.services.map((s) => s.name),
+        ...valueClasses.map((model) => model.name),
+        "createFrontend"
+    ];
+    const exportedTypeSymbols = [
+        "AnQstBridgeDiagnostic",
+        "AnQstBridgeState",
+        `${spec.widgetName}Frontend`,
+        `${spec.widgetName}Global`,
+        "AnQstGeneratedRoot"
+    ];
     return `export {};
 ${prelude}type AnQstBridgeSeverity = "info" | "warn" | "error" | "fatal";
 
@@ -4331,25 +4460,18 @@ declare class AnQstBridgeDiagnostics {
 
 ${serviceDecls}
 
-interface ${spec.widgetName}FrontendServices {
-${servicesShape}
-}
-
 interface ${spec.widgetName}Frontend {
-  diagnostics: AnQstBridgeDiagnostics;
-  services: ${spec.widgetName}FrontendServices;
+${frontendShapeLines.join("\n")}
 }
 
+declare function createFrontend(): Promise<${spec.widgetName}Frontend>;
+
 interface ${spec.widgetName}Global {
   createFrontend(): Promise<${spec.widgetName}Frontend>;
 }
 
-interface AnQstGeneratedWidgets {
-  ${spec.widgetName}: ${spec.widgetName}Global;
-}
-
 interface AnQstGeneratedRoot {
-  widgets: AnQstGeneratedWidgets;
+  ${spec.widgetName}: ${spec.widgetName}Global;
 }
 
 declare global {
@@ -4359,6 +4481,9 @@ declare global {
 
   var AnQstGenerated: AnQstGeneratedRoot;
 }
+
+export { ${exportedRuntimeSymbols.join(", ")} };
+export type { ${exportedTypeSymbols.join(", ")} };
 `;
 }
 function transpileBrowserTsToJs(source) {
@@ -5205,10 +5330,12 @@ function generateOutputs(spec, options = {}) {
         outputs[`${angularFrontendDir}/types/types.d.ts`] = renderTypeTypesDts(spec);
     }
     if (normalizedOptions.emitVanillaTS || normalizedOptions.emitVanillaJS) {
-        const vanillaBrowserTs = renderVanillaBrowserTs(spec, codecCatalog);
-        const vanillaBrowserJs = transpileBrowserTsToJs(vanillaBrowserTs);
+        const vanillaBrowserTs = renderVanillaBrowserTs(spec, codecCatalog, true);
+        const vanillaBrowserScriptTs = renderVanillaBrowserTs(spec, codecCatalog, false);
+        const vanillaBrowserJs = transpileBrowserTsToJs(vanillaBrowserScriptTs);
         if (normalizedOptions.emitVanillaTS) {
             outputs[`${vanillaTsFrontendDir}/package.json`] = renderVanillaPackage(spec, "VanillaTS");
+            outputs[`${vanillaTsFrontendDir}/index.ts`] = vanillaBrowserTs;
             outputs[`${vanillaTsFrontendDir}/index.js`] = vanillaBrowserJs;
             outputs[`${vanillaTsFrontendDir}/index.d.ts`] = renderVanillaIndexDts(spec);
         }
@@ -5241,6 +5368,52 @@ function writeGeneratedOutputs(cwd, outputs) {
         node_fs_1.default.writeFileSync(filePath, withBuildStamp(relPath, content), "utf8");
     }
 }
+function normalizeVanillaJsIndexHtml(html) {
+    let normalized = html.replace(/<script\b[^>]*src=["'](?:\.\/)?main\.js["'][^>]*>\s*<\/script>\s*/gi, "");
+    const bundleScriptTag = '  <script defer src="./main.js"></script>\n';
+    if (/<\/head>/i.test(normalized)) {
+        normalized = normalized.replace(/<\/head>/i, `${bundleScriptTag}</head>`);
+    }
+    else if (/<\/body>/i.test(normalized)) {
+        normalized = normalized.replace(/<\/body>/i, `${bundleScriptTag}</body>`);
+    }
+    else {
+        normalized = `${normalized}\n${bundleScriptTag}`;
+    }
+    return normalized;
+}
+function buildVanillaJsBrowserBundle(cwd, widgetName) {
+    const srcRoot = node_path_1.default.join(cwd, "src");
+    const srcIndexPath = node_path_1.default.join(srcRoot, "index.html");
+    const srcMainPath = node_path_1.default.join(srcRoot, "main.js");
+    const generatedRuntimePath = node_path_1.default.join((0, layout_1.resolveGeneratedLayoutPaths)(cwd, widgetName).vanillaJsFrontendRoot, "index.js");
+    if (!node_fs_1.default.existsSync(srcIndexPath)) {
+        throw new Error("VanillaJS build requires src/index.html.");
+    }
+    if (!node_fs_1.default.existsSync(srcMainPath)) {
+        throw new Error("VanillaJS build requires src/main.js.");
+    }
+    if (!node_fs_1.default.existsSync(generatedRuntimePath)) {
+        throw new Error("VanillaJS generated runtime is missing. Run generation before packaging the browser bundle.");
+    }
+    const distWebRoot = node_path_1.default.join(cwd, "dist", "browser");
+    node_fs_1.default.rmSync(distWebRoot, { recursive: true, force: true });
+    node_fs_1.default.mkdirSync(distWebRoot, { recursive: true });
+    copyDirectoryRecursive(srcRoot, distWebRoot);
+    const generatedRuntime = node_fs_1.default.readFileSync(generatedRuntimePath, "utf8").trimEnd();
+    const appMain = node_fs_1.default.readFileSync(srcMainPath, "utf8").trim();
+    const bundleSource = `${generatedRuntime}
+
+${appMain}
+
+void main(window, document, window.AnQstGenerated);
+`;
+    node_fs_1.default.writeFileSync(node_path_1.default.join(distWebRoot, "main.js"), withBuildStamp("dist/browser/main.js", bundleSource), "utf8");
+    const sourceIndexHtml = node_fs_1.default.readFileSync(srcIndexPath, "utf8");
+    const normalizedIndexHtml = normalizeVanillaJsIndexHtml(sourceIndexHtml);
+    node_fs_1.default.writeFileSync(node_path_1.default.join(distWebRoot, "index.html"), withBuildStamp("dist/browser/index.html", normalizedIndexHtml), "utf8");
+    return distWebRoot;
+}
 function listFilesRecursively(rootDir) {
     const output = [];
     const queue = [rootDir];

package/dist/src/parser.js

@@ -24,6 +24,22 @@ function qNameToText(name) {
         return name.text;
     return `${qNameToText(name.left)}.${name.right.text}`;
 }
+function textToEntityName(text) {
+    const parts = text.split(".");
+    let current = typescript_1.default.factory.createIdentifier(parts[0] ?? text);
+    for (const part of parts.slice(1)) {
+        current = typescript_1.default.factory.createQualifiedName(current, typescript_1.default.factory.createIdentifier(part));
+    }
+    return current;
+}
+function textToExpressionName(text) {
+    const parts = text.split(".");
+    let current = typescript_1.default.factory.createIdentifier(parts[0] ?? text);
+    for (const part of parts.slice(1)) {
+        current = typescript_1.default.factory.createPropertyAccessExpression(current, typescript_1.default.factory.createIdentifier(part));
+    }
+    return current;
+}
 function collectReferencedTypeNames(node) {
     const refs = new Set();
     const visit = (n) => {
@@ -33,6 +49,9 @@ function collectReferencedTypeNames(node) {
         else if (typescript_1.default.isExpressionWithTypeArguments(n) && typescript_1.default.isIdentifier(n.expression)) {
             refs.add(n.expression.text);
         }
+        else if (typescript_1.default.isTypeQueryNode(n)) {
+            refs.add(qNameToText(n.exprName));
+        }
         typescript_1.default.forEachChild(n, visit);
     };
     visit(node);
@@ -294,10 +313,118 @@ function requiresLocalImportResolution(moduleName) {
         return false;
     return moduleName.includes("/");
 }
-function parseImportedTypeDecls(specFilePath, source) {
+function collectTopLevelTypeDecls(source) {
+    const out = new Map();
+    for (const stmt of source.statements) {
+        if ((typescript_1.default.isInterfaceDeclaration(stmt) || typescript_1.default.isTypeAliasDeclaration(stmt)) && stmt.name) {
+            out.set(stmt.name.text, stmt);
+        }
+    }
+    return out;
+}
+function collectReachableImportedTypeNames(topLevelDecls, rootNames) {
+    const queue = [...rootNames];
+    const seen = new Set();
+    const ordered = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (seen.has(current))
+            continue;
+        seen.add(current);
+        const node = topLevelDecls.get(current);
+        if (!node)
+            continue;
+        ordered.push(current);
+        const decl = {
+            referencedTypeNames: collectReferencedTypeNames(node)
+        };
+        for (const ref of decl.referencedTypeNames) {
+            if (topLevelDecls.has(ref) && !seen.has(ref)) {
+                queue.push(ref);
+            }
+        }
+    }
+    return ordered;
+}
+function allocateSyntheticImportedTypeName(sourceName, usedNames) {
+    const cleaned = sourceName
+        .replace(/[^A-Za-z0-9_]/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    const base = `AnQstImported_${cleaned || "Type"}`;
+    let candidate = base;
+    let i = 2;
+    while (usedNames.has(candidate)) {
+        candidate = `${base}_${i}`;
+        i += 1;
+    }
+    usedNames.add(candidate);
+    return candidate;
+}
+function rewriteImportedTypeDecl(importedSource, node, finalName, nameMap) {
+    const renamed = typescript_1.default.isInterfaceDeclaration(node)
+        ? typescript_1.default.factory.updateInterfaceDeclaration(node, node.modifiers, typescript_1.default.factory.createIdentifier(finalName), node.typeParameters, node.heritageClauses, node.members)
+        : typescript_1.default.factory.updateTypeAliasDeclaration(node, node.modifiers, typescript_1.default.factory.createIdentifier(finalName), node.typeParameters, node.type);
+    const transformed = typescript_1.default.transform(renamed, [(context) => {
+            const visitor = (child) => {
+                if (typescript_1.default.isTypeReferenceNode(child)) {
+                    const mapped = nameMap.get(qNameToText(child.typeName));
+                    if (mapped) {
+                        return typescript_1.default.factory.updateTypeReferenceNode(child, textToEntityName(mapped), child.typeArguments);
+                    }
+                }
+                else if (typescript_1.default.isExpressionWithTypeArguments(child)) {
+                    const exprText = typescript_1.default.isIdentifier(child.expression) || typescript_1.default.isPropertyAccessExpression(child.expression)
+                        ? child.expression.getText(importedSource)
+                        : null;
+                    const mapped = exprText ? nameMap.get(exprText) : null;
+                    if (mapped) {
+                        return typescript_1.default.factory.updateExpressionWithTypeArguments(child, textToExpressionName(mapped), child.typeArguments);
+                    }
+                }
+                else if (typescript_1.default.isTypeQueryNode(child)) {
+                    const mapped = nameMap.get(qNameToText(child.exprName));
+                    if (mapped) {
+                        return typescript_1.default.factory.updateTypeQueryNode(child, textToEntityName(mapped), child.typeArguments);
+                    }
+                }
+                return typescript_1.default.visitEachChild(child, visitor, context);
+            };
+            return (root) => typescript_1.default.visitNode(root, visitor);
+        }]);
+    const rewritten = transformed.transformed[0];
+    transformed.dispose();
+    const printer = typescript_1.default.createPrinter({ newLine: typescript_1.default.NewLineKind.LineFeed });
+    const rewrittenSource = typescript_1.default.createSourceFile("__anqst_imported_decl.ts", "", typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
+    const nodeText = printer.printNode(typescript_1.default.EmitHint.Unspecified, rewritten, rewrittenSource);
+    return {
+        name: finalName,
+        kind: typescript_1.default.isInterfaceDeclaration(rewritten) ? "interface" : "type",
+        nodeText,
+        referencedTypeNames: collectReferencedTypeNames(rewritten),
+        loc: locFromNode(importedSource, node)
+    };
+}
+function createImportedAliasDecl(aliasName, targetName, loc) {
+    const nodeText = `type ${aliasName} = ${targetName};`;
+    const source = typescript_1.default.createSourceFile("__anqst_import_alias.ts", nodeText, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
+    const stmt = source.statements.find(typescript_1.default.isTypeAliasDeclaration);
+    if (!stmt) {
+        throw new Error(`Unable to synthesize imported alias declaration for ${aliasName}.`);
+    }
+    return {
+        name: aliasName,
+        kind: "type",
+        nodeText,
+        referencedTypeNames: collectReferencedTypeNames(stmt),
+        loc
+    };
+}
+function parseImportedTypeDecls(specFilePath, source, reservedTypeNames = new Set()) {
     const importedTypeDecls = new Map();
     const importedTypeSymbols = new Set();
     const specImports = [];
+    const usedImportedNames = new Set(reservedTypeNames);
     for (const stmt of source.statements) {
         if (!typescript_1.default.isImportDeclaration(stmt) || !stmt.importClause || !typescript_1.default.isStringLiteral(stmt.moduleSpecifier))
             continue;
@@ -335,10 +462,38 @@ function parseImportedTypeDecls(specFilePath, source) {
         }
         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);
+        const topLevelDecls = collectTopLevelTypeDecls(importedSource);
+        const directAliasesBySourceName = new Map();
+        for (const namedImport of importModel.namedImports) {
+            if (!topLevelDecls.has(namedImport.importedName))
+                continue;
+            const aliases = directAliasesBySourceName.get(namedImport.importedName) ?? [];
+            aliases.push(namedImport.localName);
+            directAliasesBySourceName.set(namedImport.importedName, aliases);
+        }
+        const reachableSourceNames = collectReachableImportedTypeNames(topLevelDecls, directAliasesBySourceName.keys());
+        if (reachableSourceNames.length === 0)
+            continue;
+        const canonicalNameBySourceName = new Map();
+        for (const sourceName of reachableSourceNames) {
+            const directAliases = directAliasesBySourceName.get(sourceName);
+            if (directAliases && directAliases.length > 0) {
+                canonicalNameBySourceName.set(sourceName, directAliases[0]);
+                usedImportedNames.add(directAliases[0]);
+            }
+            else {
+                canonicalNameBySourceName.set(sourceName, allocateSyntheticImportedTypeName(sourceName, usedImportedNames));
+            }
+        }
+        for (const sourceName of reachableSourceNames) {
+            const node = topLevelDecls.get(sourceName);
+            const finalName = canonicalNameBySourceName.get(sourceName);
+            if (!node || !finalName)
+                continue;
+            importedTypeDecls.set(finalName, rewriteImportedTypeDecl(importedSource, node, finalName, canonicalNameBySourceName));
+            const directAliases = directAliasesBySourceName.get(sourceName) ?? [];
+            for (const alias of directAliases.slice(1)) {
+                importedTypeDecls.set(alias, createImportedAliasDecl(alias, finalName, locFromNode(importedSource, node)));
             }
         }
     }
@@ -398,7 +553,7 @@ function parseSpecFileAst(specFilePath) {
             namespaceTypeDecls.push(parseTypeDecl(source, stmt));
         }
     }
-    const importInfo = parseImportedTypeDecls(specFilePath, source);
+    const importInfo = parseImportedTypeDecls(specFilePath, source, new Set(namespaceTypeDecls.map((decl) => decl.name)));
     return {
         filePath: specFilePath,
         widgetName: ns.name.text,

package/dist/src/verify.js

@@ -135,8 +135,10 @@ 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);
+    for (const [name, d] of spec.importedTypeDecls) {
+        if (!allDecls.has(name))
+            allDecls.set(name, d);
+    }
     const queue = [];
     const seen = new Set();
     for (const d of spec.namespaceTypeDecls)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dusted/anqst",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Opinionated backend generator for webapps.",
   "keywords": [
     "nodejs",