@distrohelena/canton-typescript-sdk 0.1.27 → 0.1.29

package/dist/daml-interface/analysis/analyzed-daml-type-definition.d.ts

@@ -1,6 +1,11 @@
 import { AnalyzedDamlEnumType, AnalyzedDamlRecordType, AnalyzedDamlVariantType } from "./analyzed-daml-type.js";
+import { DamlLfTypeParameter } from "../../daml-lf/model/daml-lf-data-type.js";
 import { TypeConReference } from "../../daml-lf/model/type-con-reference.js";
 /** A reachable named DAML data type and its complete serializable shape. */
 export type AnalyzedDamlTypeDefinition = {
     readonly identity: TypeConReference;
-} & (AnalyzedDamlRecordType | AnalyzedDamlVariantType | AnalyzedDamlEnumType);
+} & ((AnalyzedDamlRecordType & {
+    readonly typeParameters: readonly DamlLfTypeParameter[];
+}) | (AnalyzedDamlVariantType & {
+    readonly typeParameters: readonly DamlLfTypeParameter[];
+}) | AnalyzedDamlEnumType);

package/dist/daml-interface/analysis/analyzed-daml-type.d.ts

@@ -46,9 +46,15 @@ export type AnalyzedDamlEnumType = {
     readonly kind: "enum";
     readonly constructors: readonly string[];
 };
+export type AnalyzedDamlTypeVariableType = {
+    readonly kind: "typeVariable";
+    readonly name?: string;
+    readonly internedStringIndex: number;
+};
 export type AnalyzedDamlNamedReferenceType = {
     readonly kind: "namedReference";
     readonly identity: TypeConReference;
+    readonly typeArguments: readonly AnalyzedDamlType[];
 };
 /** Closed, immutable description of a DAML value serializable by the generator. */
-export type AnalyzedDamlType = AnalyzedDamlPrimitiveType | AnalyzedDamlContractIdType | AnalyzedDamlOptionalType | AnalyzedDamlListType | AnalyzedDamlTextMapType | AnalyzedDamlGenMapType | AnalyzedDamlRecordType | AnalyzedDamlVariantType | AnalyzedDamlEnumType | AnalyzedDamlNamedReferenceType;
+export type AnalyzedDamlType = AnalyzedDamlPrimitiveType | AnalyzedDamlContractIdType | AnalyzedDamlOptionalType | AnalyzedDamlListType | AnalyzedDamlTextMapType | AnalyzedDamlGenMapType | AnalyzedDamlRecordType | AnalyzedDamlVariantType | AnalyzedDamlEnumType | AnalyzedDamlTypeVariableType | AnalyzedDamlNamedReferenceType;

package/dist/daml-interface/analysis/daml-interface-analyzer.d.ts

@@ -1,12 +1,18 @@
 import { DamlLfCompilation } from "../../daml-lf/daml-lf-compilation.js";
 import { AnalyzedDamlTypeDefinition } from "./analyzed-daml-type-definition.js";
 import { AnalyzedTemplate } from "./analyzed-template.js";
+export type DamlInterfacePackageMetadata = {
+    readonly packageName: string;
+    readonly packageVersion: string;
+};
 export declare class DamlInterfaceAnalysisResult {
     readonly templates: readonly AnalyzedTemplate[];
     readonly typeDefinitions: readonly AnalyzedDamlTypeDefinition[];
+    readonly packageMetadata: ReadonlyMap<string, DamlInterfacePackageMetadata>;
     constructor(init: {
         templates: readonly AnalyzedTemplate[];
         typeDefinitions: readonly AnalyzedDamlTypeDefinition[];
+        packageMetadata?: ReadonlyMap<string, DamlInterfacePackageMetadata>;
     });
 }
 export declare class DamlInterfaceAnalyzer {

package/dist/daml-interface/analysis/daml-interface-analyzer.js

@@ -6,9 +6,11 @@ import { AnalyzedTemplate, AnalyzedTemplateField } from "./analyzed-template.js"
 export class DamlInterfaceAnalysisResult {
     templates;
     typeDefinitions;
+    packageMetadata;
     constructor(init) {
         this.templates = Object.freeze([...init.templates]);
         this.typeDefinitions = Object.freeze([...init.typeDefinitions]);
+        this.packageMetadata = new Map(init.packageMetadata);
     }
 }
 export class DamlInterfaceAnalyzer {
@@ -22,6 +24,13 @@ export class DamlInterfaceAnalyzer {
         return new DamlInterfaceAnalysisResult({
             templates,
             typeDefinitions: typeBuilder.getTypeDefinitions(),
+            packageMetadata: new Map(compilation.getPackages().map((pkg) => [
+                pkg.packageId,
+                {
+                    packageName: pkg.packageName,
+                    packageVersion: pkg.packageVersion,
+                },
+            ])),
         });
     }
     analyzeTemplateOrThrow(template, typeBuilder) {
@@ -88,15 +97,32 @@ class AnalyzedDamlTypeBuilder {
         this.semanticModel = semanticModel;
         this.toCamelCase = toCamelCase;
     }
-    buildOrThrow(type, context) {
-        if (type.typeConReference !== undefined) {
-            if (type.builtinType !== DamlLfBuiltinType.unknown) {
-                throw this.unsupported(context, "a type constructor cannot also be a builtin type");
+    buildOrThrow(type, context, typeParameters = new Map()) {
+        if (type.diagnosticForall !== undefined) {
+            throw this.unsupported(context, "retained forall types are not supported");
+        }
+        else if (type.typeVariable !== undefined) {
+            if (type.typeVariable.name === undefined) {
+                throw this.unsupported(context, `type variable '${this.getTypeVariableName(type.typeVariable)}' requires a resolved name`);
             }
             else if (type.typeArguments.length !== 0) {
-                throw this.unsupported(context, "generic named type applications are not supported");
+                throw this.unsupported(context, "applied type variables are not supported");
+            }
+            const parameter = typeParameters.get(type.typeVariable.internedStringIndex);
+            if (parameter === undefined) {
+                throw this.unsupported(context, `unbound type variable '${this.getTypeVariableName(type.typeVariable)}'`);
+            }
+            return Object.freeze({
+                kind: "typeVariable",
+                ...(parameter.name === undefined ? {} : { name: parameter.name }),
+                internedStringIndex: parameter.internedStringIndex,
+            });
+        }
+        else if (type.typeConReference !== undefined) {
+            if (type.builtinType !== DamlLfBuiltinType.unknown) {
+                throw this.unsupported(context, "a type constructor cannot also be a builtin type");
             }
-            return this.buildNamedReferenceOrThrow(type.typeConReference, context);
+            return this.buildNamedReferenceOrThrow(type.typeConReference, type.typeArguments, context, typeParameters);
         }
         switch (type.builtinType) {
             case DamlLfBuiltinType.unit:
@@ -135,24 +161,24 @@ class AnalyzedDamlTypeBuilder {
             case DamlLfBuiltinType.optional:
                 return Object.freeze({
                     kind: "optional",
-                    element: this.buildUnaryArgumentOrThrow(type, context),
+                    element: this.buildUnaryArgumentOrThrow(type, context, typeParameters),
                 });
             case DamlLfBuiltinType.list:
                 return Object.freeze({
                     kind: "list",
-                    element: this.buildUnaryArgumentOrThrow(type, context),
+                    element: this.buildUnaryArgumentOrThrow(type, context, typeParameters),
                 });
             case DamlLfBuiltinType.textMap:
                 return Object.freeze({
                     kind: "textMap",
-                    value: this.buildUnaryArgumentOrThrow(type, context),
+                    value: this.buildUnaryArgumentOrThrow(type, context, typeParameters),
                 });
             case DamlLfBuiltinType.genMap:
                 this.assertArgumentCountOrThrow(type, 2, context);
                 return Object.freeze({
                     kind: "genMap",
-                    key: this.buildOrThrow(type.typeArguments[0], context),
-                    value: this.buildOrThrow(type.typeArguments[1], context),
+                    key: this.buildOrThrow(type.typeArguments[0], context, typeParameters),
+                    value: this.buildOrThrow(type.typeArguments[1], context, typeParameters),
                 });
             case DamlLfBuiltinType.unknown:
                 throw this.unsupported(context, "the type is not serializable");
@@ -167,49 +193,50 @@ class AnalyzedDamlTypeBuilder {
             return definition;
         }));
     }
-    buildUnaryArgumentOrThrow(type, context) {
+    buildUnaryArgumentOrThrow(type, context, typeParameters) {
         this.assertArgumentCountOrThrow(type, 1, context);
-        return this.buildOrThrow(type.typeArguments[0], context);
+        return this.buildOrThrow(type.typeArguments[0], context, typeParameters);
     }
-    buildNamedReferenceOrThrow(reference, context) {
+    buildNamedReferenceOrThrow(reference, typeArguments, context, typeParameters) {
         const key = this.getDefinitionKey(reference);
         const identity = this.getCanonicalIdentity(reference, key);
+        const dataType = this.getDataTypeOrThrow(reference, context);
+        this.assertSupportedDataTypeParametersOrThrow(dataType, context);
+        this.assertNamedArgumentCountOrThrow(typeArguments, dataType, context);
+        const analyzedTypeArguments = Object.freeze(typeArguments.map((argument) => this.buildOrThrow(argument, context, typeParameters)));
         if (!this.definitions.has(key)) {
             this.definitionKeys.push(key);
             this.definitions.set(key, undefined);
-            this.definitions.set(key, this.buildNamedDefinitionOrThrow(reference, identity, context));
+            this.definitions.set(key, this.buildNamedDefinitionOrThrow(reference, identity, dataType));
         }
         return Object.freeze({
             kind: "namedReference",
             identity,
+            typeArguments: analyzedTypeArguments,
         });
     }
-    buildNamedDefinitionOrThrow(reference, identity, context) {
-        let dataType;
-        try {
-            dataType = this.semanticModel.getDataTypeOrThrow(reference);
-        }
-        catch {
-            throw this.unsupported(context, `could not resolve named type '${reference.packageId}:${reference.moduleName}:${reference.name}'`);
-        }
+    buildNamedDefinitionOrThrow(reference, identity, dataType) {
+        const typeParameters = this.createTypeParameterScope(dataType.typeParameters);
         if (dataType.definition.kind === "record") {
             return Object.freeze({
                 identity,
+                typeParameters: Object.freeze([...dataType.typeParameters]),
                 kind: "record",
                 fields: Object.freeze(dataType.definition.fields.map((field) => Object.freeze({
                     damlLabel: field.name,
                     propertyName: this.toCamelCase(field.name),
-                    type: this.buildOrThrow(field.type, `field '${field.name}' of record '${reference.name}'`),
+                    type: this.buildOrThrow(field.type, `field '${field.name}' of record '${reference.name}'`, typeParameters),
                 }))),
             });
         }
         else if (dataType.definition.kind === "variant") {
             return Object.freeze({
                 identity,
+                typeParameters: Object.freeze([...dataType.typeParameters]),
                 kind: "variant",
                 constructors: Object.freeze(dataType.definition.constructors.map((constructor) => Object.freeze({
                     constructor: constructor.name,
-                    payload: this.buildOrThrow(constructor.type, `constructor '${constructor.name}' of variant '${reference.name}'`),
+                    payload: this.buildOrThrow(constructor.type, `constructor '${constructor.name}' of variant '${reference.name}'`, typeParameters),
                 }))),
             });
         }
@@ -224,6 +251,46 @@ class AnalyzedDamlTypeBuilder {
             throw this.unsupported(context, `builtin '${type.builtinType}' requires ${expectedCount} type argument${expectedCount === 1 ? "" : "s"}`);
         }
     }
+    getDataTypeOrThrow(reference, context) {
+        try {
+            return this.semanticModel.getDataTypeOrThrow(reference);
+        }
+        catch {
+            throw this.unsupported(context, `could not resolve named type '${reference.packageId}:${reference.moduleName}:${reference.name}'`);
+        }
+    }
+    assertSupportedDataTypeParametersOrThrow(dataType, context) {
+        if (dataType.definition.kind === "enum" &&
+            dataType.typeParameters.length !== 0) {
+            throw this.unsupported(context, "generic enums are not supported");
+        }
+        for (const parameter of dataType.typeParameters) {
+            if (parameter.name === undefined) {
+                throw this.unsupported(context, `type parameter '${this.getTypeParameterName(parameter)}' requires a resolved name`);
+            }
+            else if (parameter.kind.kind !== "star") {
+                throw this.unsupported(context, `type parameter '${this.getTypeParameterName(parameter)}' must have kind '*'`);
+            }
+        }
+    }
+    assertNamedArgumentCountOrThrow(typeArguments, dataType, context) {
+        const expectedCount = dataType.typeParameters.length;
+        if (typeArguments.length !== expectedCount) {
+            throw this.unsupported(context, `named type '${dataType.name}' requires ${expectedCount} type argument${expectedCount === 1 ? "" : "s"}`);
+        }
+    }
+    createTypeParameterScope(parameters) {
+        return new Map(parameters.map((parameter) => [
+            parameter.internedStringIndex,
+            parameter,
+        ]));
+    }
+    getTypeVariableName(typeVariable) {
+        return typeVariable.name ?? `#${typeVariable.internedStringIndex}`;
+    }
+    getTypeParameterName(parameter) {
+        return parameter.name ?? `#${parameter.internedStringIndex}`;
+    }
     getDefinitionKey(reference) {
         return `${reference.packageId}::${reference.moduleName}::${reference.name}`;
     }

package/dist/daml-interface/emission/named-type-emitter.d.ts

@@ -1,4 +1,5 @@
 import { AnalyzedDamlTypeDefinition } from "../analysis/analyzed-daml-type-definition.js";
+import { DamlInterfacePackageMetadata } from "../analysis/daml-interface-analyzer.js";
 import { GeneratedNamedTypeFile } from "../emission-model/generated-named-type-file.js";
 import { GeneratedTemplateBindingFile } from "../emission-model/generated-template-binding-file.js";
 import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
@@ -7,7 +8,7 @@ export declare class NamedTypeEmitter {
     private readonly nameResolver;
     constructor(nameResolver?: TypeScriptNameResolver);
     /** Prepares shared package/module output mappings with template emission. */
-    prepareProjectOrThrow(templates: readonly import("../analysis/analyzed-template.js").AnalyzedTemplate[], definitions: readonly AnalyzedDamlTypeDefinition[]): void;
+    prepareProjectOrThrow(templates: readonly import("../analysis/analyzed-template.js").AnalyzedTemplate[], definitions: readonly AnalyzedDamlTypeDefinition[], packageMetadata?: ReadonlyMap<string, DamlInterfacePackageMetadata>): void;
     /** Emits one `types.ts` module for every reachable DAML package/module identity. */
     emitNamedTypeFiles(definitions: readonly AnalyzedDamlTypeDefinition[]): readonly GeneratedNamedTypeFile[];
     /** Emits named type files from an already prepared shared name resolver. */
@@ -19,6 +20,11 @@ export declare class NamedTypeEmitter {
     private getNamedReferences;
     private getTypeName;
     private getPrimitiveTypeName;
+    private resolveTypeParameterNames;
+    private getDefinitionTypeParameters;
+    private getTypeParameterName;
+    private getTypeParameters;
+    private getTypeParameterKey;
     private resolveModulesOrThrow;
     private resolveDefinitionNamesOrThrow;
     private resolveCollisionSafeNames;

package/dist/daml-interface/emission/named-type-emitter.js

@@ -9,8 +9,8 @@ export class NamedTypeEmitter {
         void this.nameResolver;
     }
     /** Prepares shared package/module output mappings with template emission. */
-    prepareProjectOrThrow(templates, definitions) {
-        this.nameResolver.prepareProjectOrThrow(templates, definitions);
+    prepareProjectOrThrow(templates, definitions, packageMetadata = new Map()) {
+        this.nameResolver.prepareProjectOrThrow(templates, definitions, packageMetadata);
     }
     /** Emits one `types.ts` module for every reachable DAML package/module identity. */
     emitNamedTypeFiles(definitions) {
@@ -25,14 +25,15 @@ export class NamedTypeEmitter {
         return [...modules.values()].map((module) => {
             const moduleDefinitions = definitions.filter((definition) => definition.identity.packageId === module.packageId
                 && definition.identity.moduleName === module.moduleName);
-            const externalTypeAliases = this.resolveExternalTypeAliases(module, moduleDefinitions, names);
+            const externalTypeAliases = this.resolveExternalTypeAliases(module, moduleDefinitions, modules, names);
+            const typeParameterNames = this.resolveTypeParameterNames(moduleDefinitions, names, externalTypeAliases);
             const imports = this.emitImports(module, moduleDefinitions, modules, names, externalTypeAliases);
             return new GeneratedNamedTypeFile({
                 path: module.path,
                 contents: [
                     ...imports,
                     ...(imports.length === 0 ? [] : [""]),
-                    ...moduleDefinitions.map((definition) => this.emitDefinition(definition, names, externalTypeAliases, fieldPropertyNames)),
+                    ...moduleDefinitions.map((definition) => this.emitDefinition(definition, names, externalTypeAliases, fieldPropertyNames, typeParameterNames)),
                     "",
                 ].join("\n"),
                 packageId: module.packageId,
@@ -47,19 +48,21 @@ export class NamedTypeEmitter {
             });
         });
     }
-    emitDefinition(definition, names, externalTypeAliases, fieldPropertyNames) {
+    emitDefinition(definition, names, externalTypeAliases, fieldPropertyNames, typeParameterNames) {
         const name = this.getDefinitionName(definition, names);
+        const parameters = this.getDefinitionTypeParameters(definition, typeParameterNames);
+        const declarationName = `${name}${parameters.length === 0 ? "" : `<${parameters.join(", ")}>`}`;
         if (definition.kind === "record") {
             return [
-                `export interface ${name} {`,
-                ...definition.fields.map((field, index) => `    readonly ${this.getFieldPropertyName(definition, index, fieldPropertyNames)}: ${this.getTypeName(field.type, names, externalTypeAliases)};`),
+                `export interface ${declarationName} {`,
+                ...definition.fields.map((field, index) => `    readonly ${this.getFieldPropertyName(definition, index, fieldPropertyNames)}: ${this.getTypeName(field.type, definition, names, externalTypeAliases, typeParameterNames)};`),
                 "}",
             ].join("\n");
         }
         else if (definition.kind === "variant") {
             return [
-                `export type ${name} =`,
-                ...definition.constructors.map((constructor) => `    | { readonly tag: ${JSON.stringify(constructor.constructor)}; readonly value: ${this.getTypeName(constructor.payload, names, externalTypeAliases)}; }`),
+                `export type ${declarationName} =`,
+                ...definition.constructors.map((constructor) => `    | { readonly tag: ${JSON.stringify(constructor.constructor)}; readonly value: ${this.getTypeName(constructor.payload, definition, names, externalTypeAliases, typeParameterNames)}; }`),
             ].map((line, index, lines) => index === lines.length - 1 ? `${line};` : line).join("\n");
         }
         return `export type ${name} = ${definition.constructors.map((constructor) => JSON.stringify(constructor)).join(" | ")};`;
@@ -94,11 +97,13 @@ export class NamedTypeEmitter {
                 .sort(([left], [right]) => left.localeCompare(right))
                 .map(([path, importedNames]) => `import type { ${[...importedNames.entries()]
                 .sort(([left], [right]) => left.localeCompare(right))
-                .map(([exportedName, alias]) => `${exportedName} as ${alias}`)
+                .map(([exportedName, alias]) => exportedName === alias
+                ? exportedName
+                : `${exportedName} as ${alias}`)
                 .join(", ")} } from ${JSON.stringify(path)};`),
         ];
     }
-    resolveExternalTypeAliases(module, definitions, names) {
+    resolveExternalTypeAliases(module, definitions, modules, names) {
         const references = new Map();
         for (const definition of definitions) {
             for (const reference of this.getNamedReferences(definition)) {
@@ -112,11 +117,16 @@ export class NamedTypeEmitter {
         const aliases = new Map();
         const usedNames = new Set(definitions.map((definition) => this.getDefinitionName(definition, names)));
         for (const [key, identity] of [...references.entries()].sort(([left], [right]) => left.localeCompare(right))) {
-            const baseName = this.safeTypeName(`${identity.packageId} ${identity.moduleName} ${identity.name}`);
-            let alias = baseName;
+            const referencedModule = modules.get(this.getModuleKey(identity.packageId, identity.moduleName));
+            if (referencedModule === undefined) {
+                throw new Error(`Cannot emit unresolved named DAML type '${identity.name}'`);
+            }
+            const exportedName = this.getNamedReferenceTypeName(identity, names);
+            const baseName = this.safeTypeName(`${referencedModule.namespaceAlias} ${exportedName}`);
+            let alias = exportedName;
             let escalation = 2;
             if (usedNames.has(alias)) {
-                alias = `${baseName}_${this.shortHash(key)}`;
+                alias = baseName;
             }
             while (usedNames.has(alias)) {
                 alias = `${baseName}_${this.shortHash(key)}_${escalation}`;
@@ -138,6 +148,9 @@ export class NamedTypeEmitter {
         switch (type.kind) {
             case "namedReference":
                 yield type;
+                for (const typeArgument of type.typeArguments ?? []) {
+                    yield* this.getNamedReferences(typeArgument);
+                }
                 return;
             case "contractId": return;
             case "optional":
@@ -163,29 +176,36 @@ export class NamedTypeEmitter {
                 return;
             case "primitive":
             case "enum":
+            case "typeVariable":
                 return;
         }
     }
-    getTypeName(type, names, externalTypeAliases) {
+    getTypeName(type, definition, names, externalTypeAliases, typeParameterNames) {
         switch (type.kind) {
             case "primitive":
                 return this.getPrimitiveTypeName(type.builtinType);
             case "contractId":
                 return "string";
             case "optional":
-                return `${this.getTypeName(type.element, names, externalTypeAliases)} | undefined`;
+                return `${this.getTypeName(type.element, definition, names, externalTypeAliases, typeParameterNames)} | undefined`;
             case "list":
-                return `readonly ${this.getTypeName(type.element, names, externalTypeAliases)}[]`;
+                return `readonly ${this.getTypeName(type.element, definition, names, externalTypeAliases, typeParameterNames)}[]`;
             case "textMap":
-                return `ReadonlyMap<string, ${this.getTypeName(type.value, names, externalTypeAliases)}>`;
+                return `ReadonlyMap<string, ${this.getTypeName(type.value, definition, names, externalTypeAliases, typeParameterNames)}>`;
             case "genMap":
-                return `ReadonlyMap<${this.getTypeName(type.key, names, externalTypeAliases)}, ${this.getTypeName(type.value, names, externalTypeAliases)}>`;
+                return `ReadonlyMap<${this.getTypeName(type.key, definition, names, externalTypeAliases, typeParameterNames)}, ${this.getTypeName(type.value, definition, names, externalTypeAliases, typeParameterNames)}>`;
             case "record":
             case "variant":
             case "enum":
                 throw new Error("Named DAML declarations must not contain anonymous record, variant, or enum shapes");
-            case "namedReference":
-                return externalTypeAliases.get(this.getDefinitionKey(type.identity.packageId, type.identity.moduleName, type.identity.name)) ?? this.getNamedReferenceTypeName(type.identity, names);
+            case "typeVariable":
+                return this.getTypeParameterName(definition, type, typeParameterNames);
+            case "namedReference": {
+                const name = externalTypeAliases.get(this.getDefinitionKey(type.identity.packageId, type.identity.moduleName, type.identity.name)) ?? this.getNamedReferenceTypeName(type.identity, names);
+                return (type.typeArguments?.length ?? 0) === 0
+                    ? name
+                    : `${name}<${(type.typeArguments ?? []).map((argument) => this.getTypeName(argument, definition, names, externalTypeAliases, typeParameterNames)).join(", ")}>`;
+            }
         }
     }
     getPrimitiveTypeName(type) {
@@ -210,6 +230,46 @@ export class NamedTypeEmitter {
                 throw new Error(`Cannot emit unsupported primitive DAML type '${type}'`);
         }
     }
+    resolveTypeParameterNames(definitions, names, externalTypeAliases) {
+        const values = definitions.flatMap((definition) => this.getTypeParameters(definition).map((parameter) => ({
+            definition,
+            parameter,
+        })));
+        const moduleBindings = new Set([
+            ...definitions.map((definition) => this.getDefinitionName(definition, names)),
+            ...externalTypeAliases.values(),
+        ]);
+        for (const definition of definitions) {
+            for (const runtimeType of this.getRuntimePrimitiveTypes(definition)) {
+                moduleBindings.add(runtimeType);
+            }
+        }
+        const reservedNamesByDefinition = new Map(definitions.map((definition) => [
+            this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name),
+            moduleBindings,
+        ]));
+        const resolved = this.resolveCollisionSafeNames(values, ({ parameter }) => this.safeTypeName(parameter.name ?? `T${parameter.internedStringIndex}`), ({ definition }) => this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name), "_", reservedNamesByDefinition);
+        return new Map(values.map((value) => [
+            this.getTypeParameterKey(value.definition, value.parameter.internedStringIndex),
+            resolved.get(value),
+        ]));
+    }
+    getDefinitionTypeParameters(definition, typeParameterNames) {
+        return this.getTypeParameters(definition).map((parameter) => this.getTypeParameterName(definition, parameter, typeParameterNames));
+    }
+    getTypeParameterName(definition, parameter, typeParameterNames) {
+        const name = typeParameterNames.get(this.getTypeParameterKey(definition, parameter.internedStringIndex));
+        if (name === undefined) {
+            throw new Error(`Cannot resolve generic parameter '${parameter.internedStringIndex}' for '${definition.identity.name}'`);
+        }
+        return name;
+    }
+    getTypeParameters(definition) {
+        return definition.kind === "enum" ? [] : definition.typeParameters ?? [];
+    }
+    getTypeParameterKey(definition, internedStringIndex) {
+        return `${this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name)}\u0000type-parameter\u0000${internedStringIndex}`;
+    }
     resolveModulesOrThrow(definitions) {
         const identities = new Map();
         for (const definition of definitions) {
@@ -426,7 +486,12 @@ export class NamedTypeEmitter {
                 }
                 return;
             case "enum":
+            case "typeVariable":
+                return;
             case "namedReference":
+                for (const typeArgument of type.typeArguments ?? []) {
+                    yield* this.getRuntimePrimitiveTypes(typeArgument);
+                }
                 return;
         }
     }

package/dist/daml-interface/emission/project-emitter.js

@@ -24,7 +24,7 @@ export class ProjectEmitter {
     }
     /** Emits the complete in-memory DAML interface project from analyzed templates. */
     emitProject(analysis) {
-        this.namedTypeEmitter.prepareProjectOrThrow(analysis.templates, analysis.typeDefinitions);
+        this.namedTypeEmitter.prepareProjectOrThrow(analysis.templates, analysis.typeDefinitions, analysis.packageMetadata);
         const templateBindingFiles = analysis.templates.map((template) => this.templateBindingEmitter.emitTemplateBindingFile(template));
         const namedTypeFiles = this.namedTypeEmitter.emitPreparedNamedTypeFiles(analysis.typeDefinitions, templateBindingFiles);
         const templateFiles = analysis.templates.map((template) => this.templateBindingEmitter.emitTemplateFile(template, namedTypeFiles));

package/dist/daml-interface/emission/registry-emitter.js

@@ -13,13 +13,13 @@ export class RegistryEmitter {
         return new GeneratedRegistryFile({
             path: "generated/registry.ts",
             contents: [
-                'import { DamlMaterializationError, normalizeDamlCreatedEventSource, normalizeDamlExercisedEventSource } from "@distrohelena/canton-typescript-sdk/daml-interface";',
+                'import { DamlEventSourceNormalizer, DamlMaterializationError } from "@distrohelena/canton-typescript-sdk/daml-interface";',
                 'import type { DamlCreatedEventSource, DamlExercisedEventSource } from "@distrohelena/canton-typescript-sdk/daml-interface";',
                 ...importLines,
                 "",
                 "export class GeneratedRegistry {",
                 "    public static fromCreatedEvent(event: DamlCreatedEventSource): unknown {",
-                "        const normalized = normalizeDamlCreatedEventSource(event);",
+                "        const normalized = DamlEventSourceNormalizer.normalizeCreated(event);",
                 "        switch (`${normalized.metadata.templateId.packageId}:${normalized.metadata.templateId.moduleName}:${normalized.metadata.templateId.entityName}`) {",
                 ...createdCases,
                 "            default:",
@@ -28,7 +28,7 @@ export class RegistryEmitter {
                 "    }",
                 "",
                 "    public static fromExercisedEvent(event: DamlExercisedEventSource): unknown {",
-                "        const normalized = normalizeDamlExercisedEventSource(event);",
+                "        const normalized = DamlEventSourceNormalizer.normalizeExercised(event);",
                 "        switch (`${normalized.metadata.templateId.packageId}:${normalized.metadata.templateId.moduleName}:${normalized.metadata.templateId.entityName}`) {",
                 ...exercisedCases,
                 "            default:",

package/dist/daml-interface/emission/support-file-emitter.d.ts

@@ -15,8 +15,10 @@ export declare class SupportFileEmitter {
     private getExportedSymbols;
     private describeTemplate;
     private emitDescriptorRegistry;
+    private emitFactoryBody;
     private emitDescriptor;
     private emitDefinitionDescriptor;
+    private getTypeVariableSubstitution;
     private getFieldPropertyName;
     private getFieldKey;
     private getIdentityKey;

package/dist/daml-interface/emission/support-file-emitter.js

@@ -147,9 +147,7 @@ export class SupportFileEmitter {
                 throw new Error(`Cannot emit duplicate named DAML type descriptor '${identityKey}'`);
             }
             identities.add(identityKey);
-            return [
-                `    ${JSON.stringify(identityKey)}: () => deepFreeze(${this.emitDefinitionDescriptor(definition, fieldPropertyNames)} satisfies DamlTypeDescriptor),`,
-            ].join("");
+            return `    ${JSON.stringify(identityKey)}: (typeArguments) => {\n${this.emitFactoryBody(definition, fieldPropertyNames)}\n    },`;
         });
         return new GeneratedSupportFile({
             path: "generated/support/descriptors.ts",
@@ -168,48 +166,75 @@ export class SupportFileEmitter {
                 "    return value;",
                 "}",
                 "",
-                "const generatedDamlTypeDescriptorFactories: Readonly<Record<string, () => DamlTypeDescriptor>> = Object.freeze({",
+                "const generatedDamlTypeDescriptorFactories: Readonly<Record<string, (typeArguments: readonly DamlTypeDescriptor[]) => DamlTypeDescriptor>> = Object.freeze({",
                 ...factories,
                 "});",
                 "",
-                "export const generatedDamlTypeDescriptorRegistry: DamlTypeDescriptorRegistry = Object.freeze({",
-                "    resolve(identity) {",
-                "        return generatedDamlTypeDescriptorFactories[`${identity.packageId}:${identity.moduleName}:${identity.entityName}`];",
-                "    },",
-                "});",
+                "export class GeneratedDamlTypeDescriptorRegistry {",
+                "    private constructor() {}",
+                "",
+                "    public static resolve(identity: Parameters<DamlTypeDescriptorRegistry[\"resolve\"]>[0], typeArguments: Parameters<DamlTypeDescriptorRegistry[\"resolve\"]>[1]): ReturnType<DamlTypeDescriptorRegistry[\"resolve\"]> {",
+                "        const factory = generatedDamlTypeDescriptorFactories[`${identity.packageId}:${identity.moduleName}:${identity.entityName}`];",
+                "",
+                "        return factory === undefined ? undefined : factory(typeArguments);",
+                "    }",
+                "}",
                 "",
             ].join("\n"),
         });
     }
-    emitDescriptor(type) {
+    emitFactoryBody(definition, fieldPropertyNames) {
+        const typeParameters = definition.kind === "enum" ? [] : definition.typeParameters ?? [];
+        const substitutions = new Map(typeParameters.map((parameter, index) => [
+            parameter.internedStringIndex,
+            `typeArguments[${index}]!`,
+        ]));
+        return [
+            `        if (typeArguments.length !== ${typeParameters.length}) {`,
+            `            throw new Error(${JSON.stringify(`Expected ${typeParameters.length} type arguments for ${definition.identity.packageId}:${definition.identity.moduleName}:${definition.identity.name}`)});`,
+            "        }",
+            "",
+            `        return deepFreeze(${this.emitDefinitionDescriptor(definition, fieldPropertyNames, substitutions)} satisfies DamlTypeDescriptor);`,
+        ].join("\n");
+    }
+    emitDescriptor(type, substitutions = new Map()) {
         switch (type.kind) {
             case "primitive":
                 return `{ kind: "primitive", primitive: ${JSON.stringify(type.builtinType)}${type.numericScale === undefined ? "" : `, numericScale: ${type.numericScale}`} }`;
             case "contractId":
                 return '{ kind: "contractId" }';
             case "optional":
-                return `{ kind: "optional", element: ${this.emitDescriptor(type.element)} }`;
+                return `{ kind: "optional", element: ${this.emitDescriptor(type.element, substitutions)} }`;
             case "list":
-                return `{ kind: "list", element: ${this.emitDescriptor(type.element)} }`;
+                return `{ kind: "list", element: ${this.emitDescriptor(type.element, substitutions)} }`;
             case "textMap":
-                return `{ kind: "textMap", value: ${this.emitDescriptor(type.value)} }`;
+                return `{ kind: "textMap", value: ${this.emitDescriptor(type.value, substitutions)} }`;
             case "genMap":
-                return `{ kind: "genMap", key: ${this.emitDescriptor(type.key)}, value: ${this.emitDescriptor(type.value)} }`;
+                return `{ kind: "genMap", key: ${this.emitDescriptor(type.key, substitutions)}, value: ${this.emitDescriptor(type.value, substitutions)} }`;
             case "record":
-                return `{ kind: "record", fields: [${type.fields.map((field) => `{ damlLabel: ${JSON.stringify(field.damlLabel)}, propertyName: ${JSON.stringify(field.propertyName)}, type: ${this.emitDescriptor(field.type)} }`).join(", ")}] }`;
+                return `{ kind: "record", fields: [${type.fields.map((field) => `{ damlLabel: ${JSON.stringify(field.damlLabel)}, propertyName: ${JSON.stringify(field.propertyName)}, type: ${this.emitDescriptor(field.type, substitutions)} }`).join(", ")}] }`;
             case "variant":
-                return `{ kind: "variant", constructors: [${type.constructors.map((constructor) => `{ constructor: ${JSON.stringify(constructor.constructor)}, payload: ${this.emitDescriptor(constructor.payload)} }`).join(", ")}] }`;
+                return `{ kind: "variant", constructors: [${type.constructors.map((constructor) => `{ constructor: ${JSON.stringify(constructor.constructor)}, payload: ${this.emitDescriptor(constructor.payload, substitutions)} }`).join(", ")}] }`;
             case "enum":
                 return `{ kind: "enum", constructors: [${type.constructors.map((constructor) => JSON.stringify(constructor)).join(", ")}] }`;
+            case "typeVariable":
+                return this.getTypeVariableSubstitution(type, substitutions);
             case "namedReference":
-                return `{ kind: "namedReference", identity: { packageId: ${JSON.stringify(type.identity.packageId)}, moduleName: ${JSON.stringify(type.identity.moduleName)}, entityName: ${JSON.stringify(type.identity.name)} } }`;
+                return `{ kind: "namedReference", identity: { packageId: ${JSON.stringify(type.identity.packageId)}, moduleName: ${JSON.stringify(type.identity.moduleName)}, entityName: ${JSON.stringify(type.identity.name)} }, typeArguments: [${(type.typeArguments ?? []).map((argument) => this.emitDescriptor(argument, substitutions)).join(", ")}] }`;
         }
     }
-    emitDefinitionDescriptor(definition, fieldPropertyNames) {
+    emitDefinitionDescriptor(definition, fieldPropertyNames, substitutions) {
         if (definition.kind !== "record") {
-            return this.emitDescriptor(definition);
+            return this.emitDescriptor(definition, substitutions);
+        }
+        return `{ kind: "record", fields: [${definition.fields.map((field, index) => `{ damlLabel: ${JSON.stringify(field.damlLabel)}, propertyName: ${JSON.stringify(this.getFieldPropertyName(definition, index, fieldPropertyNames))}, type: ${this.emitDescriptor(field.type, substitutions)} }`).join(", ")}] }`;
+    }
+    getTypeVariableSubstitution(type, substitutions) {
+        const substitution = substitutions.get(type.internedStringIndex);
+        if (substitution === undefined) {
+            throw new Error(`Cannot emit unbound generic DAML type variable '${type.name ?? `#${type.internedStringIndex}`}'`);
         }
-        return `{ kind: "record", fields: [${definition.fields.map((field, index) => `{ damlLabel: ${JSON.stringify(field.damlLabel)}, propertyName: ${JSON.stringify(this.getFieldPropertyName(definition, index, fieldPropertyNames))}, type: ${this.emitDescriptor(field.type)} }`).join(", ")}] }`;
+        return substitution;
     }
     getFieldPropertyName(definition, index, names) {
         const name = names.get(this.getFieldKey(definition, index));