@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

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

@@ -1,6 +1,7 @@
 import { DamlLfBuiltinType } from "../../daml-lf/model/daml-lf-builtin-type.js";
 import { GeneratedNamedTypeFile } from "../emission-model/generated-named-type-file.js";
 import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
+import { RelativeModuleSpecifier } from "./relative-module-specifier.js";
 /** Emits TypeScript declarations for reachable named DAML records, variants, and enums. */
 export class NamedTypeEmitter {
     nameResolver;
@@ -9,30 +10,31 @@ 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) {
+    emitNamedTypeFiles(definitions, moduleImportStyle) {
         this.nameResolver.prepareProjectOrThrow([], definitions);
-        return this.emitPreparedNamedTypeFiles(definitions);
+        return this.emitPreparedNamedTypeFiles(definitions, [], moduleImportStyle);
     }
     /** Emits named type files from an already prepared shared name resolver. */
-    emitPreparedNamedTypeFiles(definitions, templateFiles = []) {
+    emitPreparedNamedTypeFiles(definitions, templateFiles = [], moduleImportStyle) {
         const modules = this.resolveModulesOrThrow(definitions);
         const names = this.resolveDefinitionNamesOrThrow(definitions, this.mergeReservedNames(this.getReservedModuleExports(templateFiles), this.getReservedRuntimeBindings(definitions)));
         const fieldPropertyNames = this.resolveFieldPropertyNames(definitions);
         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 imports = this.emitImports(module, moduleDefinitions, modules, names, externalTypeAliases);
+            const externalTypeAliases = this.resolveExternalTypeAliases(module, moduleDefinitions, modules, names);
+            const typeParameterNames = this.resolveTypeParameterNames(moduleDefinitions, names, externalTypeAliases);
+            const imports = this.emitImports(module, moduleDefinitions, modules, names, externalTypeAliases, moduleImportStyle);
             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,24 +49,26 @@ 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(" | ")};`;
     }
-    emitImports(module, definitions, modules, names, externalTypeAliases) {
+    emitImports(module, definitions, modules, names, externalTypeAliases, moduleImportStyle) {
         const imports = new Map();
         const runtimeTypes = new Set();
         for (const definition of definitions) {
@@ -80,7 +84,7 @@ export class NamedTypeEmitter {
                 if (referencedModule === undefined) {
                     throw new Error(`Cannot emit unresolved named DAML type '${reference.identity.name}'`);
                 }
-                const importPath = this.relativeFilePath(module.path, referencedModule.path);
+                const importPath = this.relativeFilePath(module.path, referencedModule.path, moduleImportStyle);
                 const importedNames = imports.get(importPath) ?? new Map();
                 importedNames.set(this.getNamedReferenceTypeName(reference.identity, names), this.getExternalTypeAlias(reference.identity, externalTypeAliases));
                 imports.set(importPath, importedNames);
@@ -88,17 +92,19 @@ export class NamedTypeEmitter {
         }
         return [
             ...(runtimeTypes.size === 0 ? [] : [
-                `import type { ${[...runtimeTypes].sort().join(", ")} } from ${JSON.stringify(this.relativeFilePath(module.path, "generated/support/runtime.ts"))};`,
+                `import type { ${[...runtimeTypes].sort().join(", ")} } from ${JSON.stringify(this.relativeFilePath(module.path, "generated/support/runtime.ts", moduleImportStyle))};`,
             ]),
             ...[...imports.entries()]
                 .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 +118,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 +149,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,31 +177,44 @@ 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.getArrayElementTypeName(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(", ")}>`;
+            }
         }
     }
+    getArrayElementTypeName(type, definition, names, externalTypeAliases, typeParameterNames) {
+        const name = this.getTypeName(type, definition, names, externalTypeAliases, typeParameterNames);
+        return type.kind === "optional" || type.kind === "variant" || type.kind === "enum"
+            ? `(${name})`
+            : name;
+    }
     getPrimitiveTypeName(type) {
         switch (type) {
             case DamlLfBuiltinType.unit:
@@ -210,6 +237,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) {
@@ -360,15 +427,8 @@ export class NamedTypeEmitter {
         const [packageId, moduleName] = identityKey.split("\u0000");
         return this.getModuleKey(packageId, moduleName);
     }
-    relativeFilePath(fromPath, toPath) {
-        const from = fromPath.split("/").slice(0, -1);
-        const to = toPath.split("/");
-        while (from[0] === to[0] && from.length > 0) {
-            from.shift();
-            to.shift();
-        }
-        const relativePath = from.map(() => "..").concat(to).join("/") || ".";
-        return `${relativePath.startsWith(".") ? relativePath : `./${relativePath}`}`.replace(/\.ts$/, ".js");
+    relativeFilePath(fromPath, toPath, moduleImportStyle) {
+        return RelativeModuleSpecifier.fromPaths(fromPath, toPath, moduleImportStyle);
     }
     getDefinitionName(definition, names) {
         return this.getNamedReferenceTypeName(definition.identity, names);
@@ -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.d.ts

@@ -5,6 +5,7 @@ import { RegistryEmitter } from "./registry-emitter.js";
 import { SupportFileEmitter } from "./support-file-emitter.js";
 import { TemplateBindingEmitter } from "./template-binding-emitter.js";
 import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
+import { type DamlModuleImportStyle } from "./daml-module-import-style.js";
 export declare class ProjectEmitter {
     private readonly nameResolver;
     private readonly templateBindingEmitter;
@@ -13,5 +14,5 @@ export declare class ProjectEmitter {
     private readonly namedTypeEmitter;
     constructor(nameResolver?: TypeScriptNameResolver, templateBindingEmitter?: TemplateBindingEmitter, supportFileEmitter?: SupportFileEmitter, registryEmitter?: RegistryEmitter, namedTypeEmitter?: NamedTypeEmitter);
     /** Emits the complete in-memory DAML interface project from analyzed templates. */
-    emitProject(analysis: DamlInterfaceAnalysisResult): GeneratedDamlInterfaceProject;
+    emitProject(analysis: DamlInterfaceAnalysisResult, moduleImportStyle?: DamlModuleImportStyle): GeneratedDamlInterfaceProject;
 }

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

@@ -1,9 +1,11 @@
 import { GeneratedDamlInterfaceProject } from "../emission-model/generated-daml-interface-project.js";
+import { GeneratedSpecEmitter } from "./generated-spec-emitter.js";
 import { NamedTypeEmitter } from "./named-type-emitter.js";
 import { RegistryEmitter } from "./registry-emitter.js";
 import { SupportFileEmitter } from "./support-file-emitter.js";
 import { TemplateBindingEmitter } from "./template-binding-emitter.js";
 import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
+import { DamlModuleImportStyles, } from "./daml-module-import-style.js";
 export class ProjectEmitter {
     nameResolver;
     templateBindingEmitter;
@@ -23,34 +25,42 @@ export class ProjectEmitter {
         void this.registryEmitter;
     }
     /** Emits the complete in-memory DAML interface project from analyzed templates. */
-    emitProject(analysis) {
-        this.namedTypeEmitter.prepareProjectOrThrow(analysis.templates, analysis.typeDefinitions);
+    emitProject(analysis, moduleImportStyle = DamlModuleImportStyles.esm) {
+        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));
+        const namedTypeFiles = this.namedTypeEmitter.emitPreparedNamedTypeFiles(analysis.typeDefinitions, templateBindingFiles, moduleImportStyle);
+        const templateFiles = analysis.templates.map((template) => this.templateBindingEmitter.emitTemplateFile(template, namedTypeFiles, moduleImportStyle));
         const supportFiles = [
             ...this.supportFileEmitter.emitSupportFiles(analysis, namedTypeFiles),
-            ...this.supportFileEmitter.emitNamespaceFiles(new GeneratedDamlInterfaceProject({ templateFiles, namedTypeFiles })),
+            ...this.supportFileEmitter.emitNamespaceFiles(new GeneratedDamlInterfaceProject({ templateFiles, namedTypeFiles }), moduleImportStyle),
         ];
         const baseProject = new GeneratedDamlInterfaceProject({
             templateFiles,
             namedTypeFiles,
             supportFiles,
         });
-        const registryFile = this.registryEmitter.emitRegistry(baseProject);
+        const registryFile = this.registryEmitter.emitRegistry(baseProject, moduleImportStyle);
         const projectWithRegistry = new GeneratedDamlInterfaceProject({
             templateFiles,
             namedTypeFiles,
             supportFiles,
             registryFile,
         });
-        const indexFile = this.supportFileEmitter.emitIndexFile(projectWithRegistry);
+        const indexFile = this.supportFileEmitter.emitIndexFile(projectWithRegistry, moduleImportStyle);
+        const project = new GeneratedDamlInterfaceProject({
+            templateFiles,
+            namedTypeFiles,
+            supportFiles,
+            registryFile,
+            indexFile,
+        });
         return new GeneratedDamlInterfaceProject({
             templateFiles,
             namedTypeFiles,
             supportFiles,
             registryFile,
             indexFile,
+            specFiles: GeneratedSpecEmitter.emitSpecFiles(project, analysis, moduleImportStyle),
         });
     }
 }

package/dist/daml-interface/emission/registry-emitter.d.ts

@@ -1,7 +1,8 @@
 import { GeneratedDamlInterfaceProject } from "../emission-model/generated-daml-interface-project.js";
 import { GeneratedRegistryFile } from "../emission-model/generated-registry-file.js";
+import { type DamlModuleImportStyle } from "./daml-module-import-style.js";
 export declare class RegistryEmitter {
     /** Emits a registry that dispatches created and exercised events by template id. */
-    emitRegistry(project: GeneratedDamlInterfaceProject): GeneratedRegistryFile;
+    emitRegistry(project: GeneratedDamlInterfaceProject, moduleImportStyle?: DamlModuleImportStyle): GeneratedRegistryFile;
     private emitCases;
 }

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

@@ -1,11 +1,10 @@
 import { GeneratedRegistryFile } from "../emission-model/generated-registry-file.js";
+import { RelativeModuleSpecifier } from "./relative-module-specifier.js";
 export class RegistryEmitter {
     /** Emits a registry that dispatches created and exercised events by template id. */
-    emitRegistry(project) {
+    emitRegistry(project, moduleImportStyle) {
         const importLines = project.templateFiles.map((file) => {
-            const modulePath = file.path
-                .replace(/^generated\//, "./")
-                .replace(/\.ts$/, ".js");
+            const modulePath = RelativeModuleSpecifier.fromPaths("generated/registry.ts", file.path, moduleImportStyle);
             return `import { ${file.binding.className} } from "${modulePath}";`;
         });
         const createdCases = this.emitCases(project, "fromCreatedEvent");
@@ -13,13 +12,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 +27,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/relative-module-specifier.d.ts

@@ -0,0 +1,7 @@
+import { type DamlModuleImportStyle } from "./daml-module-import-style.js";
+/** Formats generated-project relative module specifiers for the selected execution mode. */
+export declare class RelativeModuleSpecifier {
+    private constructor();
+    /** Resolves a generated TypeScript target path relative to a generated source path. */
+    static fromPaths(fromPath: string, toPath: string, moduleImportStyle?: DamlModuleImportStyle): string;
+}

package/dist/daml-interface/emission/relative-module-specifier.js

@@ -0,0 +1,17 @@
+import { DamlModuleImportStyles, } from "./daml-module-import-style.js";
+/** Formats generated-project relative module specifiers for the selected execution mode. */
+export class RelativeModuleSpecifier {
+    constructor() { }
+    /** Resolves a generated TypeScript target path relative to a generated source path. */
+    static fromPaths(fromPath, toPath, moduleImportStyle = DamlModuleImportStyles.esm) {
+        const from = fromPath.split("/").slice(0, -1);
+        const to = toPath.replace(/\.ts$/, "").split("/");
+        while (from[0] === to[0] && from.length > 0) {
+            from.shift();
+            to.shift();
+        }
+        const relativePath = from.map(() => "..").concat(to).join("/") || ".";
+        const prefixedPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+        return moduleImportStyle === DamlModuleImportStyles.esm ? `${prefixedPath}.js` : prefixedPath;
+    }
+}

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

@@ -2,21 +2,24 @@ import { DamlInterfaceAnalysisResult } from "../analysis/daml-interface-analyzer
 import { GeneratedDamlInterfaceProject } from "../emission-model/generated-daml-interface-project.js";
 import { GeneratedNamedTypeFile } from "../emission-model/generated-named-type-file.js";
 import { GeneratedSupportFile } from "../emission-model/generated-support-file.js";
+import { type DamlModuleImportStyle } from "./daml-module-import-style.js";
 export declare class SupportFileEmitter {
     /** Emits shared support files for the generated DAML interface project. */
     emitSupportFiles(analysis: DamlInterfaceAnalysisResult, namedTypeFiles?: readonly GeneratedNamedTypeFile[]): readonly GeneratedSupportFile[];
     /** Emits one barrel module for each generated DAML package/module namespace. */
-    emitNamespaceFiles(project: GeneratedDamlInterfaceProject): readonly GeneratedSupportFile[];
+    emitNamespaceFiles(project: GeneratedDamlInterfaceProject, moduleImportStyle?: DamlModuleImportStyle): readonly GeneratedSupportFile[];
     /** Emits the generated project index file. */
-    emitIndexFile(project: GeneratedDamlInterfaceProject): GeneratedSupportFile;
+    emitIndexFile(project: GeneratedDamlInterfaceProject, moduleImportStyle?: DamlModuleImportStyle): GeneratedSupportFile;
     private getNamespaceGroups;
     private getFileNameWithoutExtension;
     private assertDistinctModuleExportedSymbols;
     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

@@ -1,4 +1,5 @@
 import { GeneratedSupportFile } from "../emission-model/generated-support-file.js";
+import { RelativeModuleSpecifier } from "./relative-module-specifier.js";
 export class SupportFileEmitter {
     /** Emits shared support files for the generated DAML interface project. */
     emitSupportFiles(analysis, namedTypeFiles = []) {
@@ -18,25 +19,23 @@ export class SupportFileEmitter {
         ];
     }
     /** Emits one barrel module for each generated DAML package/module namespace. */
-    emitNamespaceFiles(project) {
+    emitNamespaceFiles(project, moduleImportStyle) {
         return this.getNamespaceGroups(project).map((group) => new GeneratedSupportFile({
             path: `${group.directoryPath}/index.ts`,
             contents: `${[
-                ...(group.namedTypeFile === undefined ? [] : ["export * from \"./types.js\";"]),
+                ...(group.namedTypeFile === undefined ? [] : [`export * from ${JSON.stringify(RelativeModuleSpecifier.fromPaths(`${group.directoryPath}/index.ts`, group.namedTypeFile.path, moduleImportStyle))};`]),
                 ...group.templateFiles
-                    .map((file) => this.getFileNameWithoutExtension(file.path))
-                    .map((fileName) => `export * from "./${fileName}.js";`),
+                    .map((file) => `export * from ${JSON.stringify(RelativeModuleSpecifier.fromPaths(`${group.directoryPath}/index.ts`, file.path, moduleImportStyle))};`),
             ].join("\n")}\n`,
         }));
     }
     /** Emits the generated project index file. */
-    emitIndexFile(project) {
+    emitIndexFile(project, moduleImportStyle) {
         const exportLines = this.getNamespaceGroups(project)
-            .map((group) => `export * as ${group.alias} from "${group.directoryPath
-            .replace(/^generated\//, "./")}/index.js";`);
+            .map((group) => `export * as ${group.alias} from ${JSON.stringify(RelativeModuleSpecifier.fromPaths("generated/index.ts", `${group.directoryPath}/index.ts`, moduleImportStyle))};`);
         const lines = [
             ...exportLines,
-            'export * from "./registry.js";',
+            `export * from ${JSON.stringify(RelativeModuleSpecifier.fromPaths("generated/index.ts", "generated/registry.ts", moduleImportStyle))};`,
         ];
         return new GeneratedSupportFile({
             path: "generated/index.ts",
@@ -147,9 +146,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 +165,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));

package/dist/daml-interface/emission/template-binding-emitter.d.ts

@@ -2,6 +2,7 @@ import { AnalyzedTemplate } from "../analysis/analyzed-template.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";
+import { type DamlModuleImportStyle } from "./daml-module-import-style.js";
 /** Emits typed contract and exercise-event bindings for analyzed DAML templates. */
 export declare class TemplateBindingEmitter {
     private readonly nameResolver;
@@ -9,7 +10,7 @@ export declare class TemplateBindingEmitter {
     /** Prepares stable collision-safe names before emitting a complete project. */
     prepareTemplatesOrThrow(templates: readonly AnalyzedTemplate[]): void;
     /** Emits a generated TypeScript file for one analyzed DAML template. */
-    emitTemplateFile(template: AnalyzedTemplate, namedTypeFiles?: readonly GeneratedNamedTypeFile[]): GeneratedTemplateBindingFile;
+    emitTemplateFile(template: AnalyzedTemplate, namedTypeFiles?: readonly GeneratedNamedTypeFile[], moduleImportStyle?: DamlModuleImportStyle): GeneratedTemplateBindingFile;
     /** Emits binding metadata without source, for resolving named declaration exports first. */
     emitTemplateBindingFile(template: AnalyzedTemplate): GeneratedTemplateBindingFile;
     private createBinding;
@@ -20,7 +21,11 @@ export declare class TemplateBindingEmitter {
     private emitTemplateDescriptor;
     private emitDescriptor;
     private getTypeName;
+    private getArrayElementTypeName;
     private getPrimitiveTypeName;
+    private resolveRuntimeWrapperTypeNames;
+    private getSdkName;
+    private emitImportedName;
     private normalizeType;
     private resolveNamedReferences;
     private walkNamedReferences;