@dusted/anqst 1.0.1 → 1.5.1

package/README.md

@@ -75,6 +75,8 @@ Settings file (`./AnQst/<WidgetName>.settings.json`) owns project-local AnQst co
   - If `QWidget` is enabled and `angular.json` exists:
     - runs production Angular build
     - embeds built web assets into generated Qt widget `webapp/`.
+  - Generated Qt integration CMake consumes the existing `./AnQst/generated` widget tree and fails fast if the required generated files are missing.
+  - Downstream CMake no longer invokes `npm`, `npx`, or `anqst`; run `anqst build` first, then build C++ against the generated tree.
   - If `--designerplugin` is enabled:
     - requires `ANQST_WEBBASE_DIR`
     - emits plugin sources in `./AnQst/generated/backend/cpp/qt/<WidgetName>_widget/designerPlugin`
@@ -140,3 +142,16 @@ code AnQst/BurgerConstructor.AnQst.d.ts
 npx @dusted/anqst test
 npx @dusted/anqst build
 ```
+
+## Two-stage workflow
+
+```bash
+# Stage 1: Node/Angular/generation environment
+npx @dusted/anqst build
+
+# Stage 2: pure Qt/CMake environment, consuming the generated tree
+cmake -S . -B build
+cmake --build build
+```
+
+Both stages must use the exact outputs from the same prior `anqst build` invocation.

package/dist/src/app.js

@@ -19,6 +19,12 @@ const project_1 = require("./project");
 const layout_1 = require("./layout");
 const parser_1 = require("./parser");
 const verify_1 = require("./verify");
+class CliUsageError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CliUsageError";
+    }
+}
 const ANQSTGEN_ACTIVE_STAMP_FILE = ".anqstgen-version-active.json";
 function renderHelp() {
     const version = readActiveBuildStamp();
@@ -261,6 +267,7 @@ function runBuild(cwd, designerPlugin = false) {
             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 Angular build");
         }
         if (generationTargets.emitNodeExpressWs) {
@@ -295,12 +302,12 @@ function parseSpecCommandArg(commandName, specArg, extraArgs) {
     const positional = [];
     for (const arg of allArgs) {
         if (arg.startsWith("-")) {
-            throw new Error(`Unknown ${commandName} flag '${arg}'. ${usageFor(commandName)}`);
+            throw new CliUsageError(`Unknown ${commandName} flag '${arg}'. ${usageFor(commandName)}`);
         }
         positional.push(arg);
     }
     if (positional.length !== 1) {
-        throw new Error(usageFor(commandName));
+        throw new CliUsageError(usageFor(commandName));
     }
     return positional[0];
 }
@@ -327,12 +334,12 @@ function parseBuildCommandArgs(specArg, extraArgs) {
             continue;
         }
         if (arg.startsWith("-")) {
-            throw new Error(`Unknown build flag '${arg}'. ${usageFor("build")}`);
+            throw new CliUsageError(`Unknown build flag '${arg}'. ${usageFor("build")}`);
         }
         positional.push(arg);
     }
     if (positional.length > 0) {
-        throw new Error(`Unexpected extra argument '${positional[0]}'. ${usageFor("build")}`);
+        throw new CliUsageError(`Unexpected extra argument '${positional[0]}'. ${usageFor("build")}`);
     }
     return { designerPlugin };
 }
@@ -346,15 +353,15 @@ function parseCleanCommandArgs(specArg, extraArgs) {
             continue;
         }
         if (arg.startsWith("-")) {
-            throw new Error(`Unknown clean flag '${arg}'. Use -f or --force.`);
+            throw new CliUsageError(`Unknown clean flag '${arg}'. Use -f or --force.`);
         }
         if (targetPathArg !== null) {
-            throw new Error(`Unexpected extra argument '${arg}'. Usage: anqst clean <path> [-f|--force]`);
+            throw new CliUsageError(`Unexpected extra argument '${arg}'. Usage: anqst clean <path> [-f|--force]`);
         }
         targetPathArg = arg;
     }
     if (targetPathArg === null) {
-        throw new Error("Usage: anqst clean <path> [-f|--force]");
+        throw new CliUsageError("Usage: anqst clean <path> [-f|--force]");
     }
     return { targetPathArg, force };
 }
@@ -475,6 +482,19 @@ function renderInstallAliasMessage() {
         return text;
     return `\x1b[38;5;214m${text}\x1b[0m`;
 }
+function formatUnexpectedError(error) {
+    if (!(error instanceof Error)) {
+        return `[AnQst] ${String(error)}`;
+    }
+    const lines = [`[AnQst] ${error.message}`];
+    const stack = typeof error.stack === "string" ? error.stack.trim() : "";
+    if (stack.length > 0) {
+        lines.push("");
+        lines.push("Stack trace:");
+        lines.push(stack);
+    }
+    return lines.join("\n");
+}
 function runCommand(command, specArg, extraArgs = []) {
     try {
         if (!command) {
@@ -544,8 +564,11 @@ function runCommand(command, specArg, extraArgs = []) {
             console.error((0, errors_1.formatVerifyError)(error));
             return 1;
         }
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`[AnQst] ${message}`);
+        if (error instanceof CliUsageError) {
+            console.error(error.message);
+            return 1;
+        }
+        console.error(formatUnexpectedError(error));
         return 1;
     }
 }

package/dist/src/base93.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE93_ALPHABET = void 0;
+exports.emitBase93Encoder = emitBase93Encoder;
+exports.emitBase93Decoder = emitBase93Decoder;
+exports.BASE93_ALPHABET = Array.from({ length: 95 }, (_, i) => String.fromCharCode(0x20 + i))
+    .filter(c => c !== '"' && c !== '\\')
+    .join('');
+function emitBase93Encoder() {
+    return `function(d) {
+var A = "${exports.BASE93_ALPHABET}", n = d.length, f = n >>> 2, r = n & 3,
+o = new Array(f * 5 + (r ? r + 1 : 0)), p = 0, i, v, b, j;
+for (i = 0; i < f; i++) {
+b = i << 2;
+v = ((d[b] << 24) | (d[b+1] << 16) | (d[b+2] << 8) | d[b+3]) >>> 0;
+o[p+4] = A[v % 93]; v = (v / 93) | 0;
+o[p+3] = A[v % 93]; v = (v / 93) | 0;
+o[p+2] = A[v % 93]; v = (v / 93) | 0;
+o[p+1] = A[v % 93];
+o[p] = A[(v / 93) | 0];
+p += 5;
+}
+if (r) {
+b = f << 2; v = 0;
+for (j = 0; j < r; j++) v = (v << 8) | d[b + j];
+for (j = r; j >= 0; j--) { o[p + j] = A[v % 93]; v = (v / 93) | 0; }
+}
+return o.join("");
+}`;
+}
+function emitBase93Decoder() {
+    return `function(s) {
+var n = s.length, f = (n / 5) | 0, r = n - f * 5,
+o = new Uint8Array(f * 4 + (r ? r - 1 : 0)), p = 0, i, v, c, b;
+for (i = 0; i < f; i++) {
+b = i * 5;
+c = s.charCodeAt(b); v = c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0);
+c = s.charCodeAt(b + 1); v = v * 93 + c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0);
+c = s.charCodeAt(b + 2); v = v * 93 + c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0);
+c = s.charCodeAt(b + 3); v = v * 93 + c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0);
+c = s.charCodeAt(b + 4); v = v * 93 + c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0);
+o[p] = v >>> 24; o[p+1] = (v >>> 16) & 255; o[p+2] = (v >>> 8) & 255; o[p+3] = v & 255;
+p += 4;
+}
+if (r) {
+v = 0;
+for (i = 0; i < r; i++) { c = s.charCodeAt(f * 5 + i); v = v * 93 + c - 32 - ((c > 34) ? 1 : 0) - ((c > 92) ? 1 : 0); }
+for (i = r - 2; i >= 0; i--) { o[p + i] = v & 255; v = (v / 256) | 0; }
+}
+return o;
+}`;
+}

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

@@ -0,0 +1,468 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundaryTransportAnalyzer = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const errors_1 = require("./errors");
+const boundary_codec_model_1 = require("./boundary-codec-model");
+const boundary_codec_leaves_1 = require("./boundary-codec-leaves");
+const BUILTIN_TYPE_REFS = new Set(["Array", "ReadonlyArray", "Record", "Map", "Partial", "Promise"]);
+function isStringLikeUnion(node) {
+    return node.types.every((part) => {
+        if (typescript_1.default.isLiteralTypeNode(part) && typescript_1.default.isStringLiteral(part.literal))
+            return true;
+        return part.kind === typescript_1.default.SyntaxKind.StringKeyword;
+    });
+}
+function isBooleanLikeUnion(node) {
+    return node.types.every((part) => {
+        if (typescript_1.default.isLiteralTypeNode(part)) {
+            return part.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword || part.literal.kind === typescript_1.default.SyntaxKind.FalseKeyword;
+        }
+        return part.kind === typescript_1.default.SyntaxKind.BooleanKeyword;
+    });
+}
+function isNumberLikeUnion(node) {
+    return node.types.every((part) => {
+        if (typescript_1.default.isLiteralTypeNode(part) && typescript_1.default.isNumericLiteral(part.literal))
+            return true;
+        return part.kind === typescript_1.default.SyntaxKind.NumberKeyword || part.kind === typescript_1.default.SyntaxKind.BigIntKeyword;
+    });
+}
+function filterNullishUnionParts(types) {
+    return types.filter((part) => part.kind !== typescript_1.default.SyntaxKind.NullKeyword && part.kind !== typescript_1.default.SyntaxKind.UndefinedKeyword);
+}
+function collectFiniteStringLiterals(node) {
+    const values = [];
+    for (const part of node.types) {
+        if (!typescript_1.default.isLiteralTypeNode(part) || !typescript_1.default.isStringLiteral(part.literal))
+            return null;
+        values.push(part.literal.text);
+    }
+    return values;
+}
+function collectFiniteBooleanLiterals(node) {
+    const values = [];
+    for (const part of node.types) {
+        if (!typescript_1.default.isLiteralTypeNode(part))
+            return null;
+        if (part.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword) {
+            values.push(true);
+            continue;
+        }
+        if (part.literal.kind === typescript_1.default.SyntaxKind.FalseKeyword) {
+            values.push(false);
+            continue;
+        }
+        return null;
+    }
+    return values;
+}
+function collectFiniteNumberLiterals(node) {
+    const values = [];
+    for (const part of node.types) {
+        if (!typescript_1.default.isLiteralTypeNode(part) || !typescript_1.default.isNumericLiteral(part.literal))
+            return null;
+        values.push(Number(part.literal.text));
+    }
+    return values;
+}
+function finiteDomainSymbolForValue(value) {
+    if (typeof value === "boolean")
+        return value ? "True" : "False";
+    if (typeof value === "number") {
+        const text = Number.isInteger(value) ? `${value}` : `${value}`.replace(/\./g, "_");
+        return (0, boundary_codec_model_1.sanitizeIdentifier)(`Value_${text.replace(/-/g, "neg_")}`);
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return "Empty";
+    const direct = (0, boundary_codec_model_1.sanitizeIdentifier)(trimmed);
+    return direct.length > 0 ? direct : "Value";
+}
+function buildFiniteDomain(primitive, values) {
+    const seen = new Set();
+    const variants = [];
+    for (const value of values) {
+        const key = `${typeof value}:${String(value)}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        variants.push({
+            code: variants.length,
+            symbolicName: finiteDomainSymbolForValue(value),
+            tsLiteralText: typeof value === "string" ? JSON.stringify(value) : `${value}`,
+            value
+        });
+    }
+    return { primitive, variants };
+}
+function unsupported(path, typeText, reason) {
+    throw new errors_1.VerifyError(`Boundary codec planning failed for '${path.join(".") || typeText}': ${reason} (${typeText}).`);
+}
+class BoundaryTransportAnalyzer {
+    constructor(spec) {
+        this.spec = spec;
+        this.declNodes = new Map();
+        this.namedNodes = new Map();
+        for (const decl of this.collectDecls()) {
+            const node = (0, boundary_codec_model_1.parseTypeDeclNode)(decl.nodeText);
+            if (node) {
+                this.declNodes.set(decl.name, node);
+            }
+        }
+    }
+    analyzeTypeText(typeText, path) {
+        const rootNode = (0, boundary_codec_model_1.parseTypeNodeFromText)(typeText);
+        const root = this.resolveTypeNode(rootNode, typeText, path, [], this.defaultIdentityParts(rootNode, typeText, path));
+        return {
+            typeText,
+            tsTypeText: (0, boundary_codec_model_1.stripAnQstType)(typeText),
+            root,
+            summary: summarizeAnalysis(root)
+        };
+    }
+    collectDecls() {
+        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);
+        return [...out.values()];
+    }
+    nodeMeta(typeText, path, identityParts) {
+        const normalizedParts = identityParts.filter((part) => part.trim().length > 0);
+        return {
+            typeText,
+            path,
+            typeIdentityKey: normalizedParts.join("::") || (0, boundary_codec_model_1.stripAnQstType)(typeText).trim(),
+            cppNameHintParts: normalizedParts.length > 0 ? normalizedParts : (path.length > 0 ? path : [(0, boundary_codec_model_1.stripAnQstType)(typeText).trim() || "AnonymousType"])
+        };
+    }
+    defaultIdentityParts(node, typeText, path) {
+        if (typescript_1.default.isTypeReferenceNode(node)) {
+            const name = (0, boundary_codec_model_1.qNameText)(node.typeName);
+            if (!name.startsWith("AnQst.Type.") && !BUILTIN_TYPE_REFS.has(name)) {
+                return [name];
+            }
+        }
+        return path.length > 0 ? [...path] : [(0, boundary_codec_model_1.stripAnQstType)(typeText).trim() || "AnonymousType"];
+    }
+    createFiniteDomainAnalysis(typeText, path, identityParts, domain) {
+        return {
+            nodeKind: "finite-domain",
+            ...this.nodeMeta(typeText, path, identityParts),
+            domain
+        };
+    }
+    createStructAnalysis(typeText, path, members, stack, identityParts) {
+        const fields = members
+            .filter((member) => {
+            return typescript_1.default.isPropertySignature(member) && !!member.type && typescript_1.default.isIdentifier(member.name);
+        })
+            .map((member) => {
+            const fieldPath = [...path, member.name.text];
+            const fieldIdentityParts = [...identityParts, member.name.text];
+            const child = this.resolveTypeNode(member.type, member.type.getText(), fieldPath, stack, fieldIdentityParts);
+            return {
+                name: member.name.text,
+                optional: !!member.questionToken,
+                typeText: member.type.getText(),
+                path: fieldPath,
+                typeIdentityKey: child.typeIdentityKey,
+                cppNameHintParts: child.cppNameHintParts,
+                reconstructionKey: member.name.text,
+                node: child
+            };
+        });
+        return {
+            nodeKind: "struct",
+            ...this.nodeMeta(typeText, path, identityParts),
+            fields,
+            reconstruction: "object"
+        };
+    }
+    resolveNamedReference(name, decl) {
+        const existing = this.namedNodes.get(name);
+        if (existing) {
+            return existing;
+        }
+        const placeholder = {
+            nodeKind: "named",
+            ...this.nodeMeta(name, [name], [name]),
+            name,
+            target: null
+        };
+        this.namedNodes.set(name, placeholder);
+        placeholder.target = typescript_1.default.isInterfaceDeclaration(decl)
+            ? this.createStructAnalysis(name, [name], decl.members, [name], [name])
+            : this.resolveTypeNode(decl.type, name, [name], [name], [name]);
+        return placeholder;
+    }
+    resolveTypeNode(node, typeText, path, stack, identityParts) {
+        if (typescript_1.default.isParenthesizedTypeNode(node)) {
+            return this.resolveTypeNode(node.type, typeText, path, stack, identityParts);
+        }
+        if (typescript_1.default.isTypeLiteralNode(node)) {
+            return this.createStructAnalysis(typeText, path, node.members, stack, identityParts);
+        }
+        if (typescript_1.default.isArrayTypeNode(node)) {
+            return {
+                nodeKind: "array",
+                ...this.nodeMeta(typeText, path, identityParts),
+                elementTypeText: node.elementType.getText(),
+                element: this.resolveTypeNode(node.elementType, node.elementType.getText(), [...path, "Item"], stack, [...identityParts, "Item"]),
+                requiresCountMetadata: true,
+                reconstruction: "array"
+            };
+        }
+        if (typescript_1.default.isTupleTypeNode(node)) {
+            unsupported(path, typeText, "tuple transport is not supported by the whole-boundary planner");
+        }
+        if (typescript_1.default.isLiteralTypeNode(node)) {
+            if (typescript_1.default.isStringLiteral(node.literal)) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("string", [node.literal.text]));
+            }
+            if (typescript_1.default.isNumericLiteral(node.literal)) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("number", [Number(node.literal.text)]));
+            }
+            if (node.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword || node.literal.kind === typescript_1.default.SyntaxKind.FalseKeyword) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("boolean", [node.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword]));
+            }
+        }
+        if (typescript_1.default.isUnionTypeNode(node)) {
+            const filtered = filterNullishUnionParts(node.types);
+            if (filtered.length !== node.types.length) {
+                unsupported(path, typeText, "nullish unions are not supported; use explicit optional members instead");
+            }
+            const finiteStringVariants = collectFiniteStringLiterals(node);
+            if (finiteStringVariants) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("string", finiteStringVariants));
+            }
+            const finiteBooleanVariants = collectFiniteBooleanLiterals(node);
+            if (finiteBooleanVariants) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("boolean", finiteBooleanVariants));
+            }
+            const finiteNumberVariants = collectFiniteNumberLiterals(node);
+            if (finiteNumberVariants) {
+                return this.createFiniteDomainAnalysis(typeText, path, identityParts, buildFiniteDomain("number", finiteNumberVariants));
+            }
+            if (isStringLikeUnion(node)) {
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("string", "string"),
+                    fixedWidth: false
+                };
+            }
+            if (isBooleanLikeUnion(node)) {
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("boolean", "boolean"),
+                    fixedWidth: true
+                };
+            }
+            if (isNumberLikeUnion(node)) {
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("number", "number"),
+                    fixedWidth: true
+                };
+            }
+            unsupported(path, typeText, "union transport is only supported for string, boolean, or number-like unions");
+        }
+        if (typescript_1.default.isTypeReferenceNode(node)) {
+            const name = (0, boundary_codec_model_1.qNameText)(node.typeName);
+            const rawText = node.getText();
+            if (name === "Array" || name === "ReadonlyArray") {
+                const arg = node.typeArguments?.[0];
+                if (!arg) {
+                    unsupported(path, rawText, "array type is missing its element type");
+                }
+                return {
+                    nodeKind: "array",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    elementTypeText: arg.getText(),
+                    element: this.resolveTypeNode(arg, arg.getText(), [...path, "Item"], stack, [...identityParts, "Item"]),
+                    requiresCountMetadata: true,
+                    reconstruction: "array"
+                };
+            }
+            if (name === "Record" || name === "Map") {
+                const leaf = (0, boundary_codec_leaves_1.resolveLeafCapability)("object", "object");
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: leaf,
+                    fixedWidth: false
+                };
+            }
+            if (name === "Partial") {
+                unsupported(path, rawText, "generic Partial<T> transport is not supported");
+            }
+            if (name === "Promise") {
+                unsupported(path, rawText, "Promise transport is not supported");
+            }
+            if (rawText.trim() === "AnQst.Type.stringArray") {
+                const leaf = (0, boundary_codec_leaves_1.resolveLeafCapability)("string", "string");
+                return {
+                    nodeKind: "array",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    elementTypeText: "string",
+                    element: {
+                        nodeKind: "leaf",
+                        ...this.nodeMeta("string", [...path, "Item"], [...identityParts, "Item"]),
+                        leaf: leaf,
+                        fixedWidth: false
+                    },
+                    requiresCountMetadata: true,
+                    reconstruction: "array"
+                };
+            }
+            const leaf = (0, boundary_codec_leaves_1.resolveLeafCapability)(rawText, name);
+            if (leaf) {
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf,
+                    fixedWidth: leaf.fixedByteWidth !== null
+                };
+            }
+            const decl = this.declNodes.get(name);
+            if (decl) {
+                return this.resolveNamedReference(name, decl);
+            }
+        }
+        switch (node.kind) {
+            case typescript_1.default.SyntaxKind.StringKeyword:
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("string", "string"),
+                    fixedWidth: false
+                };
+            case typescript_1.default.SyntaxKind.BooleanKeyword:
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("boolean", "boolean"),
+                    fixedWidth: true
+                };
+            case typescript_1.default.SyntaxKind.NumberKeyword:
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("number", "number"),
+                    fixedWidth: true
+                };
+            case typescript_1.default.SyntaxKind.BigIntKeyword:
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("bigint", "bigint"),
+                    fixedWidth: true
+                };
+            case typescript_1.default.SyntaxKind.ObjectKeyword:
+                return {
+                    nodeKind: "leaf",
+                    ...this.nodeMeta(typeText, path, identityParts),
+                    leaf: (0, boundary_codec_leaves_1.resolveLeafCapability)("object", "object"),
+                    fixedWidth: false
+                };
+            default:
+                unsupported(path, typeText, "no transport analysis rule exists for this type");
+        }
+    }
+}
+exports.BoundaryTransportAnalyzer = BoundaryTransportAnalyzer;
+function summarizeAnalysis(node) {
+    const used = new Set();
+    const visitedNamed = new Set();
+    const visit = (current) => {
+        switch (current.nodeKind) {
+            case "leaf":
+                used.add(current.leaf.key);
+                return {
+                    hasBlobLeaves: current.leaf.region === "blob",
+                    hasStringLeaves: current.leaf.region === "string",
+                    hasBinaryLeaves: current.leaf.region === "binary",
+                    hasDynamicLeaves: current.leaf.region === "dynamic",
+                    hasRepeatedStructures: false,
+                    hasOptionalPresence: false,
+                    hasFiniteDomains: false,
+                    usedLeafCapabilities: []
+                };
+            case "named":
+                if (visitedNamed.has(current.name)) {
+                    return {
+                        hasBlobLeaves: false,
+                        hasStringLeaves: false,
+                        hasBinaryLeaves: false,
+                        hasDynamicLeaves: false,
+                        hasRepeatedStructures: false,
+                        hasOptionalPresence: false,
+                        hasFiniteDomains: false,
+                        usedLeafCapabilities: []
+                    };
+                }
+                visitedNamed.add(current.name);
+                return visit(current.target);
+            case "finite-domain":
+                return {
+                    hasBlobLeaves: false,
+                    hasStringLeaves: false,
+                    hasBinaryLeaves: false,
+                    hasDynamicLeaves: false,
+                    hasRepeatedStructures: false,
+                    hasOptionalPresence: false,
+                    hasFiniteDomains: true,
+                    usedLeafCapabilities: []
+                };
+            case "array": {
+                const inner = visit(current.element);
+                return {
+                    hasBlobLeaves: inner.hasBlobLeaves,
+                    hasStringLeaves: inner.hasStringLeaves,
+                    hasBinaryLeaves: inner.hasBinaryLeaves,
+                    hasDynamicLeaves: inner.hasDynamicLeaves,
+                    hasRepeatedStructures: true,
+                    hasOptionalPresence: inner.hasOptionalPresence,
+                    hasFiniteDomains: inner.hasFiniteDomains,
+                    usedLeafCapabilities: []
+                };
+            }
+            case "struct":
+                return current.fields.reduce((acc, field) => {
+                    const next = visit(field.node);
+                    return {
+                        hasBlobLeaves: acc.hasBlobLeaves || next.hasBlobLeaves,
+                        hasStringLeaves: acc.hasStringLeaves || next.hasStringLeaves,
+                        hasBinaryLeaves: acc.hasBinaryLeaves || next.hasBinaryLeaves,
+                        hasDynamicLeaves: acc.hasDynamicLeaves || next.hasDynamicLeaves,
+                        hasRepeatedStructures: acc.hasRepeatedStructures || next.hasRepeatedStructures,
+                        hasOptionalPresence: acc.hasOptionalPresence || field.optional || next.hasOptionalPresence,
+                        hasFiniteDomains: acc.hasFiniteDomains || next.hasFiniteDomains,
+                        usedLeafCapabilities: []
+                    };
+                }, {
+                    hasBlobLeaves: false,
+                    hasStringLeaves: false,
+                    hasBinaryLeaves: false,
+                    hasDynamicLeaves: false,
+                    hasRepeatedStructures: false,
+                    hasOptionalPresence: false,
+                    hasFiniteDomains: false,
+                    usedLeafCapabilities: []
+                });
+        }
+    };
+    const summary = visit(node);
+    return {
+        ...summary,
+        usedLeafCapabilities: [...used]
+    };
+}