@dusted/anqst 1.5.0 → 1.5.1

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();
@@ -296,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];
 }
@@ -328,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 };
 }
@@ -347,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 };
 }
@@ -476,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) {
@@ -545,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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BASE93_ALPHABET = void 0;
 exports.emitBase93Encoder = emitBase93Encoder;
 exports.emitBase93Decoder = emitBase93Decoder;
-exports.emitBase93CppFunctions = emitBase93CppFunctions;
 exports.BASE93_ALPHABET = Array.from({ length: 95 }, (_, i) => String.fromCharCode(0x20 + i))
     .filter(c => c !== '"' && c !== '\\')
     .join('');
@@ -51,74 +50,3 @@ for (i = r - 2; i >= 0; i--) { o[p + i] = v & 255; v = (v / 256) | 0; }
 return o;
 }`;
 }
-function emitBase93CppFunctions() {
-    return `inline int base93AlphabetIndex(char c) {
-  const unsigned char uc = static_cast<unsigned char>(c);
-  return static_cast<int>(uc) - 32 - (uc > 34) - (uc > 92);
-}
-
-inline std::string base93Encode(const std::vector<std::uint8_t>& d) {
-  static constexpr char A[] = "${exports.BASE93_ALPHABET}";
-  const std::size_t n = d.size();
-  const std::size_t f = n >> 2;
-  const std::size_t r = n & 3;
-  std::string o(f * 5 + (r ? r + 1 : 0), '\\0');
-  std::size_t p = 0;
-  for (std::size_t i = 0; i < f; ++i) {
-    const std::size_t b = i << 2;
-    std::uint32_t v =
-      (static_cast<std::uint32_t>(d[b]) << 24) |
-      (static_cast<std::uint32_t>(d[b + 1]) << 16) |
-      (static_cast<std::uint32_t>(d[b + 2]) << 8) |
-      static_cast<std::uint32_t>(d[b + 3]);
-    o[p + 4] = A[v % 93u]; v /= 93u;
-    o[p + 3] = A[v % 93u]; v /= 93u;
-    o[p + 2] = A[v % 93u]; v /= 93u;
-    o[p + 1] = A[v % 93u];
-    o[p] = A[v / 93u];
-    p += 5;
-  }
-  if (r) {
-    const std::size_t b = f << 2;
-    std::uint32_t v = 0;
-    for (std::size_t j = 0; j < r; ++j) v = (v << 8) | d[b + j];
-    for (std::size_t j = r + 1; j-- > 0;) {
-      o[p + j] = A[v % 93u];
-      v /= 93u;
-    }
-  }
-  return o;
-}
-
-inline std::vector<std::uint8_t> base93Decode(const std::string& s) {
-  const std::size_t n = s.size();
-  const std::size_t f = n / 5;
-  const std::size_t r = n - f * 5;
-  std::vector<std::uint8_t> o(f * 4 + (r ? r - 1 : 0));
-  std::size_t p = 0;
-  for (std::size_t i = 0; i < f; ++i) {
-    const std::size_t b = i * 5;
-    std::uint32_t v = static_cast<std::uint32_t>(base93AlphabetIndex(s[b]));
-    v = v * 93u + static_cast<std::uint32_t>(base93AlphabetIndex(s[b + 1]));
-    v = v * 93u + static_cast<std::uint32_t>(base93AlphabetIndex(s[b + 2]));
-    v = v * 93u + static_cast<std::uint32_t>(base93AlphabetIndex(s[b + 3]));
-    v = v * 93u + static_cast<std::uint32_t>(base93AlphabetIndex(s[b + 4]));
-    o[p] = static_cast<std::uint8_t>(v >> 24);
-    o[p + 1] = static_cast<std::uint8_t>((v >> 16) & 255u);
-    o[p + 2] = static_cast<std::uint8_t>((v >> 8) & 255u);
-    o[p + 3] = static_cast<std::uint8_t>(v & 255u);
-    p += 4;
-  }
-  if (r) {
-    std::uint32_t v = 0;
-    for (std::size_t i = 0; i < r; ++i) {
-      v = v * 93u + static_cast<std::uint32_t>(base93AlphabetIndex(s[f * 5 + i]));
-    }
-    for (std::size_t i = r - 1; i-- > 0;) {
-      o[p + i] = static_cast<std::uint8_t>(v & 255u);
-      v /= 256u;
-    }
-  }
-  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]
+    };
+}