@distrohelena/canton-typescript-sdk 0.1.24 → 0.1.26

package/dist/daml-interface/emission/template-binding-emitter.js

@@ -1,119 +1,420 @@
+import { DamlLfBuiltinType } from "../../daml-lf/model/daml-lf-builtin-type.js";
 import { GeneratedChoiceBinding } from "../emission-model/generated-choice-binding.js";
-import { GeneratedTemplateBinding } from "../emission-model/generated-template-binding.js";
-import { GeneratedTemplateBindingField, } from "../emission-model/generated-template-binding.js";
+import { GeneratedTemplateBinding, GeneratedTemplateBindingField, } from "../emission-model/generated-template-binding.js";
 import { GeneratedTemplateBindingFile } from "../emission-model/generated-template-binding-file.js";
 import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
+/** Emits typed contract and exercise-event bindings for analyzed DAML templates. */
 export class TemplateBindingEmitter {
     nameResolver;
     constructor(nameResolver = new TypeScriptNameResolver()) {
         this.nameResolver = nameResolver;
         void this.nameResolver;
     }
+    /** Prepares stable collision-safe names before emitting a complete project. */
+    prepareTemplatesOrThrow(templates) {
+        this.nameResolver.prepareTemplatesOrThrow(templates);
+    }
     /** Emits a generated TypeScript file for one analyzed DAML template. */
-    emitTemplateFile(template) {
-        const binding = this.createBinding(template);
-        const contents = this.emitContents(binding);
+    emitTemplateFile(template, namedTypeFiles = []) {
+        const namedReferences = this.resolveNamedReferences(template, namedTypeFiles);
+        const binding = this.createBinding(template, namedReferences);
+        return new GeneratedTemplateBindingFile({
+            path: binding.path,
+            contents: this.emitContents(binding, namedReferences),
+            binding,
+        });
+    }
+    /** Emits binding metadata without source, for resolving named declaration exports first. */
+    emitTemplateBindingFile(template) {
+        const namedReferences = this.resolveNamedReferences(template, []);
+        const binding = this.createBinding(template, namedReferences);
         return new GeneratedTemplateBindingFile({
             path: binding.path,
-            contents,
+            contents: "",
             binding,
         });
     }
-    createBinding(template) {
+    createBinding(template, namedReferences) {
         return new GeneratedTemplateBinding({
-            className: template.className,
+            templateIdentityKey: this.nameResolver.getTemplateIdentityKey(template),
+            namespaceAlias: this.nameResolver.getNamespaceAlias(template),
+            className: this.nameResolver.getTemplateClassName(template),
             templateIdLiteral: this.nameResolver.getTemplateIdLiteral(template),
             path: this.nameResolver.getTemplateFilePath(template),
             createFieldsTypeName: this.nameResolver.getCreateFieldsTypeName(template),
             createdEventTypeName: this.nameResolver.getCreatedEventTypeName(template),
             createFields: template.createFields.map((field) => new GeneratedTemplateBindingField({
                 name: field.name,
-                propertyName: field.propertyName,
-                typeName: this.nameResolver.getTypeName(field.type),
+                propertyName: this.nameResolver.getFieldPropertyName(template, field),
+                constructorParameterName: this.nameResolver.getFieldConstructorParameterName(template, field),
+                type: this.normalizeType(field.type),
+                typeName: this.getTypeName(this.normalizeType(field.type), namedReferences),
             })),
             choices: template.choices.map((choice) => new GeneratedChoiceBinding({
+                choiceIdentityKey: this.nameResolver.getChoiceIdentityKey(template, choice),
                 name: choice.name,
-                methodName: choice.methodName,
+                methodName: this.nameResolver.getChoiceMethodName(template, choice),
                 choiceTypeName: this.nameResolver.getChoiceTypeName(template, choice),
                 exercisedEventTypeName: this.nameResolver.getExercisedEventTypeName(template, choice),
-                parameterName: choice.parameterName,
-                parameterTypeName: this.nameResolver.getTypeName(choice.parameterType),
-                returnTypeName: this.nameResolver.getTypeName(choice.returnType),
+                parameterName: this.nameResolver.getChoiceParameterName(template, choice),
+                parameterType: this.normalizeType(choice.parameterType),
+                parameterTypeName: this.getTypeName(this.normalizeType(choice.parameterType), namedReferences),
+                returnType: this.normalizeType(choice.returnType),
+                returnTypeName: this.getTypeName(this.normalizeType(choice.returnType), namedReferences),
             })),
         });
     }
-    emitContents(binding) {
-        const createFields = binding.createFields
-            .map((field) => `    ${field.propertyName}: ${field.typeName};`)
-            .join("\n");
-        const choiceInterfaces = binding.choices
-            .map((choice) => [
-            `export interface ${choice.choiceTypeName} {`,
-            `    ${choice.parameterName}: ${choice.parameterTypeName};`,
-            "}",
-        ].join("\n"))
-            .join("\n\n");
-        const exercisedEvents = binding.choices
-            .map((choice) => [
-            `export interface ${choice.exercisedEventTypeName} {`,
-            `    choiceName: "${choice.name}";`,
-            `    result: ${choice.returnTypeName};`,
-            "}",
-        ].join("\n"))
-            .join("\n\n");
-        const choiceMethods = binding.choices
-            .map((choice) => [
-            `    public static ${choice.methodName}(`,
-            "        contractId: string,",
-            `        choice: ${choice.choiceTypeName},`,
-            "    ): unknown {",
-            "        return {",
-            "            contractId,",
-            `            choiceName: "${choice.name}",`,
-            "            choice,",
-            "        };",
-            "    }",
-        ].join("\n"))
-            .join("\n\n");
-        const exercisedReturnType = binding.choices.length === 1
-            ? binding.choices[0].exercisedEventTypeName
-            : binding.choices
-                .map((choice) => choice.exercisedEventTypeName)
-                .join(" | ");
+    emitContents(binding, namedReferences) {
+        const imports = this.emitImports(binding, namedReferences);
+        const fields = binding.createFields.map((field) => `    readonly ${field.propertyName}: ${field.typeName};`);
+        const constructorParameters = binding.createFields.map((field) => `${field.constructorParameterName}: ${field.typeName}`);
+        const constructorAssignments = binding.createFields.map((field) => `        this.${field.propertyName} = ${field.constructorParameterName};`);
+        const orderedArguments = binding.createFields.map((field) => `            fields.${field.propertyName},`);
+        const exercisedReturnType = binding.choices.length === 0
+            ? "never"
+            : binding.choices.map((choice) => choice.exercisedEventTypeName).join(" | ");
         return [
+            ...imports,
+            "",
             `export interface ${binding.createFieldsTypeName} {`,
-            createFields,
+            ...fields,
             "}",
             "",
-            choiceInterfaces,
+            this.emitTemplateClass(binding, constructorParameters, constructorAssignments, orderedArguments, exercisedReturnType),
+            ...(binding.choices.length === 0 ? [] : ["", ...binding.choices.flatMap((choice) => [
+                    this.emitChoiceEventClass(binding, choice),
+                    "",
+                ])]),
+        ].join("\n");
+    }
+    emitImports(binding, namedReferences) {
+        const namedImports = new Map();
+        for (const reference of namedReferences.values()) {
+            const imported = namedImports.get(reference.path) ?? new Map();
+            imported.set(reference.exportedName, reference.alias);
+            namedImports.set(reference.path, imported);
+        }
+        return [
+            'import { DamlMaterializationError, DamlTemplate, decodeDamlValue, materializeDamlValue, normalizeDamlCreatedEventSource, normalizeDamlExercisedEventSource } from "@distrohelena/canton-typescript-sdk/daml-interface";',
+            'import type { DamlCreatedEventSource, DamlDate, DamlExercisedEventMetadata, DamlExercisedEventSource, DamlNormalizedExercisedEvent, DamlNumeric, DamlParty, DamlTimestamp, DamlTypeDescriptor, DamlUnit } from "@distrohelena/canton-typescript-sdk/daml-interface";',
+            `import { generatedDamlTypeDescriptorRegistry } from ${JSON.stringify(this.relativeFilePath(binding.path, "generated/support/descriptors.ts"))};`,
+            ...[...namedImports.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([path, imported]) => `import type { ${[...imported.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([name, alias]) => `${name} as ${alias}`).join(", ")} } from ${JSON.stringify(path)};`),
+        ];
+    }
+    emitTemplateClass(binding, constructorParameters, constructorAssignments, orderedArguments, exercisedReturnType) {
+        return [
+            `export class ${binding.className} extends DamlTemplate implements ${binding.createFieldsTypeName} {`,
+            `    public static readonly templateId = ${JSON.stringify(binding.templateIdLiteral)};`,
+            `    private static readonly descriptor: DamlTypeDescriptor = ${this.emitTemplateDescriptor(binding)};`,
             "",
-            `export interface ${binding.createdEventTypeName} {`,
-            "    templateId: string;",
-            `    payload: ${binding.createFieldsTypeName};`,
-            "}",
+            ...binding.createFields.map((field) => `    public readonly ${field.propertyName}: ${field.typeName};`),
+            ...(binding.createFields.length === 0 ? [] : [""]),
+            `    public constructor(contractId: string${constructorParameters.length === 0 ? "" : `, ${constructorParameters.join(", ")}`}) {`,
+            "        super(contractId);",
+            ...constructorAssignments,
+            "    }",
+            "",
+            `    public static fromCreatedEvent(event: DamlCreatedEventSource): ${binding.className} {`,
+            "        const normalized = normalizeDamlCreatedEventSource(event);",
+            `        ${binding.className}.assertTemplateIdentity(normalized.metadata.templateId);`,
+            `        const fields = materializeDamlValue<${binding.createFieldsTypeName}>(decodeDamlValue(normalized.payload, ${binding.className}.descriptor, generatedDamlTypeDescriptorRegistry, "create arguments"));`,
+            `        return new ${binding.className}(`,
+            "            normalized.contractId,",
+            ...orderedArguments,
+            "        );",
+            "    }",
+            "",
+            `    public static fromExercisedEvent(event: DamlExercisedEventSource): ${exercisedReturnType} {`,
+            "        const normalized = normalizeDamlExercisedEventSource(event);",
+            `        ${binding.className}.assertTemplateIdentity(normalized.metadata.templateId);`,
+            "        switch (normalized.choice) {",
+            ...binding.choices.map((choice) => `            case ${JSON.stringify(choice.name)}:\n                return ${choice.exercisedEventTypeName}.fromNormalizedEvent(normalized);`),
+            "            default:",
+            `                throw new DamlMaterializationError("choice", \`Unexpected choice '\${normalized.choice}' for template '${binding.templateIdLiteral}'\`);`,
+            "        }",
+            "    }",
             "",
-            exercisedEvents,
+            "    private static assertTemplateIdentity(identity: { readonly packageId: string; readonly moduleName: string; readonly entityName: string }): void {",
+            `        if (identity.packageId !== ${JSON.stringify(this.packageId(binding))} || identity.moduleName !== ${JSON.stringify(this.moduleName(binding))} || identity.entityName !== ${JSON.stringify(this.entityName(binding))}) {`,
+            `            throw new DamlMaterializationError("template ID", \`Expected template '${binding.templateIdLiteral}' but received '\${identity.packageId}:\${identity.moduleName}:\${identity.entityName}'\`);`,
+            "        }",
+            "    }",
+            "}",
+        ].join("\n");
+    }
+    emitChoiceEventClass(binding, choice) {
+        return [
+            `export class ${choice.exercisedEventTypeName} {`,
+            `    private static readonly argumentDescriptor: DamlTypeDescriptor = ${this.emitDescriptor(choice.parameterType)};`,
+            `    private static readonly resultDescriptor: DamlTypeDescriptor = ${this.emitDescriptor(choice.returnType)};`,
             "",
-            `export class ${binding.className} {`,
-            `    public static readonly templateId = "${binding.templateIdLiteral}";`,
+            `    public readonly choiceName = ${JSON.stringify(choice.name)} as const;`,
+            "    public readonly contractId: string;",
+            `    public readonly argument: ${choice.parameterTypeName};`,
+            `    public readonly result: ${choice.returnTypeName};`,
+            "    public readonly consuming: boolean;",
+            "    public readonly metadata: DamlExercisedEventMetadata;",
             "",
-            `    public static create(fields: ${binding.createFieldsTypeName}): unknown {`,
-            "        return {",
-            `            templateId: ${binding.className}.templateId,`,
-            "            fields,",
-            "        };",
+            "    public constructor(contractId: string, argument: " + choice.parameterTypeName + ", result: " + choice.returnTypeName + ", consuming: boolean, metadata: DamlExercisedEventMetadata) {",
+            "        this.contractId = contractId;",
+            "        this.argument = argument;",
+            "        this.result = result;",
+            "        this.consuming = consuming;",
+            "        this.metadata = metadata;",
             "    }",
             "",
-            choiceMethods,
+            `    public static fromExercisedEvent(event: DamlExercisedEventSource): ${choice.exercisedEventTypeName} {`,
+            "        const normalized = normalizeDamlExercisedEventSource(event);",
+            `        ${choice.exercisedEventTypeName}.assertTemplateIdentity(normalized.metadata.templateId);`,
+            `        return ${choice.exercisedEventTypeName}.fromNormalizedEvent(normalized);`,
+            "    }",
             "",
-            `    public static decodeCreatedEvent(event: unknown): ${binding.createdEventTypeName} {`,
-            `        return event as ${binding.createdEventTypeName};`,
+            `    public static fromNormalizedEvent(event: DamlNormalizedExercisedEvent): ${choice.exercisedEventTypeName} {`,
+            `        ${choice.exercisedEventTypeName}.assertTemplateIdentity(event.metadata.templateId);`,
+            `        if (event.choice !== ${JSON.stringify(choice.name)}) {`,
+            `            throw new DamlMaterializationError("choice", \`Expected choice '${choice.name}' but received '\${event.choice}'\`);`,
+            "        }",
+            `        const argument = materializeDamlValue<${choice.parameterTypeName}>(decodeDamlValue(event.argument, ${choice.exercisedEventTypeName}.argumentDescriptor, generatedDamlTypeDescriptorRegistry, "choice argument"));`,
+            `        const result = materializeDamlValue<${choice.returnTypeName}>(decodeDamlValue(event.result, ${choice.exercisedEventTypeName}.resultDescriptor, generatedDamlTypeDescriptorRegistry, "exercise result"));`,
+            `        return new ${choice.exercisedEventTypeName}(event.contractId, argument, result, event.consuming, event.metadata);`,
             "    }",
             "",
-            `    public static decodeExercisedEvent(event: unknown): ${exercisedReturnType} {`,
-            `        return event as ${exercisedReturnType};`,
+            "    private static assertTemplateIdentity(identity: { readonly packageId: string; readonly moduleName: string; readonly entityName: string }): void {",
+            `        if (identity.packageId !== ${JSON.stringify(this.packageId(binding))} || identity.moduleName !== ${JSON.stringify(this.moduleName(binding))} || identity.entityName !== ${JSON.stringify(this.entityName(binding))}) {`,
+            `            throw new DamlMaterializationError("template ID", \`Expected template '${binding.templateIdLiteral}' but received '\${identity.packageId}:\${identity.moduleName}:\${identity.entityName}'\`);`,
+            "        }",
             "    }",
             "}",
-        ].filter((item) => item.length > 0).join("\n");
+        ].join("\n");
+    }
+    emitTemplateDescriptor(binding) {
+        return `{ kind: "record", fields: [${binding.createFields.map((field) => `{ damlLabel: ${JSON.stringify(field.name)}, propertyName: ${JSON.stringify(field.propertyName)}, type: ${this.emitDescriptor(field.type)} }`).join(", ")}] }`;
+    }
+    emitDescriptor(type) {
+        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)} }`;
+            case "list":
+                return `{ kind: "list", element: ${this.emitDescriptor(type.element)} }`;
+            case "textMap":
+                return `{ kind: "textMap", value: ${this.emitDescriptor(type.value)} }`;
+            case "genMap":
+                return `{ kind: "genMap", key: ${this.emitDescriptor(type.key)}, value: ${this.emitDescriptor(type.value)} }`;
+            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(", ")}] }`;
+            case "variant":
+                return `{ kind: "variant", constructors: [${type.constructors.map((constructor) => `{ constructor: ${JSON.stringify(constructor.constructor)}, payload: ${this.emitDescriptor(constructor.payload)} }`).join(", ")}] }`;
+            case "enum":
+                return `{ kind: "enum", constructors: [${type.constructors.map((constructor) => JSON.stringify(constructor)).join(", ")}] }`;
+            case "namedReference":
+                return `{ kind: "namedReference", identity: { packageId: ${JSON.stringify(type.identity.packageId)}, moduleName: ${JSON.stringify(type.identity.moduleName)}, entityName: ${JSON.stringify(type.identity.name)} } }`;
+        }
+    }
+    getTypeName(type, namedReferences) {
+        switch (type.kind) {
+            case "primitive":
+                return this.getPrimitiveTypeName(type.builtinType);
+            case "contractId":
+                return "string";
+            case "optional":
+                return `${this.getTypeName(type.element, namedReferences)} | undefined`;
+            case "list":
+                return `readonly ${this.getTypeName(type.element, namedReferences)}[]`;
+            case "textMap":
+                return `ReadonlyMap<string, ${this.getTypeName(type.value, namedReferences)}>`;
+            case "genMap":
+                return `ReadonlyMap<${this.getTypeName(type.key, namedReferences)}, ${this.getTypeName(type.value, namedReferences)}>`;
+            case "record":
+                return `{ ${type.fields.map((field) => `readonly ${field.propertyName}: ${this.getTypeName(field.type, namedReferences)};`).join(" ")} }`;
+            case "variant":
+                return type.constructors.map((constructor) => `{ readonly tag: ${JSON.stringify(constructor.constructor)}; readonly value: ${this.getTypeName(constructor.payload, namedReferences)}; }`).join(" | ");
+            case "enum":
+                return type.constructors.map((constructor) => JSON.stringify(constructor)).join(" | ");
+            case "namedReference":
+                return this.getNamedReference(type.identity, namedReferences).alias;
+        }
+    }
+    getPrimitiveTypeName(type) {
+        switch (type) {
+            case DamlLfBuiltinType.unit: return "DamlUnit";
+            case DamlLfBuiltinType.bool: return "boolean";
+            case DamlLfBuiltinType.int64: return "bigint";
+            case DamlLfBuiltinType.date: return "DamlDate";
+            case DamlLfBuiltinType.timestamp: return "DamlTimestamp";
+            case DamlLfBuiltinType.numeric: return "DamlNumeric";
+            case DamlLfBuiltinType.party: return "DamlParty";
+            case DamlLfBuiltinType.text: return "string";
+            default: throw new Error(`Cannot emit unsupported primitive DAML type '${type}'`);
+        }
+    }
+    normalizeType(type) {
+        if ("kind" in type) {
+            return type;
+        }
+        else if (type.builtinType === DamlLfBuiltinType.contractId) {
+            if (type.typeArguments.length !== 1) {
+                throw new Error("DAML ContractId requires exactly one type argument");
+            }
+            return { kind: "contractId" };
+        }
+        else if (type.typeConReference !== undefined) {
+            return { kind: "namedReference", identity: type.typeConReference };
+        }
+        const arguments_ = type.typeArguments.map((argument) => this.normalizeType(argument));
+        switch (type.builtinType) {
+            case DamlLfBuiltinType.optional:
+                return { kind: "optional", element: arguments_[0] ?? { kind: "primitive", builtinType: DamlLfBuiltinType.text } };
+            case DamlLfBuiltinType.list:
+                return { kind: "list", element: arguments_[0] ?? { kind: "primitive", builtinType: DamlLfBuiltinType.text } };
+            case DamlLfBuiltinType.textMap:
+                return { kind: "textMap", value: arguments_[0] ?? { kind: "primitive", builtinType: DamlLfBuiltinType.text } };
+            case DamlLfBuiltinType.genMap:
+                return { kind: "genMap", key: arguments_[0] ?? { kind: "primitive", builtinType: DamlLfBuiltinType.text }, value: arguments_[1] ?? { kind: "primitive", builtinType: DamlLfBuiltinType.text } };
+            case DamlLfBuiltinType.unit:
+            case DamlLfBuiltinType.bool:
+            case DamlLfBuiltinType.int64:
+            case DamlLfBuiltinType.date:
+            case DamlLfBuiltinType.timestamp:
+            case DamlLfBuiltinType.numeric:
+            case DamlLfBuiltinType.party:
+            case DamlLfBuiltinType.text:
+                return { kind: "primitive", builtinType: type.builtinType, numericScale: type.numericScale };
+            case DamlLfBuiltinType.unknown:
+                throw new Error("Cannot emit an unknown DAML type");
+            default:
+                throw new Error("Cannot emit unsupported DAML type");
+        }
+    }
+    resolveNamedReferences(template, namedTypeFiles) {
+        const identities = new Map();
+        for (const type of [
+            ...template.createFields.map((field) => this.normalizeType(field.type)),
+            ...template.choices.flatMap((choice) => [
+                this.normalizeType(choice.parameterType),
+                this.normalizeType(choice.returnType),
+            ]),
+        ]) {
+            for (const reference of this.walkNamedReferences(type)) {
+                identities.set(this.getNamedReferenceKey(reference.identity), reference);
+            }
+        }
+        const aliases = new Map();
+        const usedAliases = new Set();
+        for (const [key, reference] of [...identities.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+            const file = namedTypeFiles.find((candidate) => candidate.packageId === reference.identity.packageId
+                && candidate.moduleName === reference.identity.moduleName);
+            const exportedName = file?.exportedTypeNamesByIdentity.get(key);
+            if (file === undefined || exportedName === undefined) {
+                if (namedTypeFiles.length !== 0) {
+                    throw new Error(`Cannot emit unresolved named DAML type '${reference.identity.name}'`);
+                }
+                aliases.set(key, reference.identity.name);
+                continue;
+            }
+            const baseAlias = this.toTypeName(`${reference.identity.packageId} ${reference.identity.moduleName} ${exportedName}`);
+            let alias = baseAlias;
+            let escalation = 2;
+            while (usedAliases.has(alias)) {
+                alias = `${baseAlias}_${this.shortHash(key)}_${escalation}`;
+                escalation += 1;
+            }
+            usedAliases.add(alias);
+            aliases.set(key, alias);
+        }
+        return new Map([...identities.entries()].map(([key, reference]) => {
+            const file = namedTypeFiles.find((candidate) => candidate.packageId === reference.identity.packageId
+                && candidate.moduleName === reference.identity.moduleName);
+            const exportedName = file?.exportedTypeNamesByIdentity.get(key);
+            const alias = aliases.get(key);
+            if (file === undefined || exportedName === undefined) {
+                return [key, {
+                        path: "",
+                        exportedName: reference.identity.name,
+                        alias: alias ?? reference.identity.name,
+                    }];
+            }
+            return [key, {
+                    path: this.relativeFilePath(this.nameResolver.getTemplateFilePath(template), file.path),
+                    exportedName,
+                    alias: alias,
+                }];
+        }));
+    }
+    *walkNamedReferences(type) {
+        switch (type.kind) {
+            case "namedReference":
+                yield type;
+                return;
+            case "contractId": return;
+            case "optional":
+            case "list":
+                yield* this.walkNamedReferences(type.element);
+                return;
+            case "textMap":
+                yield* this.walkNamedReferences(type.value);
+                return;
+            case "genMap":
+                yield* this.walkNamedReferences(type.key);
+                yield* this.walkNamedReferences(type.value);
+                return;
+            case "record":
+                for (const field of type.fields) {
+                    yield* this.walkNamedReferences(field.type);
+                }
+                return;
+            case "variant":
+                for (const constructor of type.constructors) {
+                    yield* this.walkNamedReferences(constructor.payload);
+                }
+                return;
+            case "primitive":
+            case "enum": return;
+        }
+    }
+    getNamedReference(identity, namedReferences) {
+        const reference = namedReferences.get(this.getNamedReferenceKey(identity));
+        if (reference === undefined) {
+            throw new Error(`Cannot resolve named DAML type '${identity.name}'`);
+        }
+        return reference;
+    }
+    getNamedReferenceKey(identity) {
+        return `${identity.packageId}\u0000${identity.moduleName}\u0000${identity.name}`;
+    }
+    toTypeName(value) {
+        const normalized = value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^A-Za-z0-9]+/g, " ").trim();
+        const name = normalized.split(/\s+/).map((part) => `${part[0]?.toUpperCase()}${part.slice(1)}`).join("");
+        return /^[0-9]/.test(name) ? `_${name}` : name;
+    }
+    shortHash(value) {
+        let hash = 0x811c9dc5;
+        for (const character of value) {
+            hash ^= character.charCodeAt(0);
+            hash = Math.imul(hash, 0x01000193);
+        }
+        return (hash >>> 0).toString(36).padStart(6, "0").slice(-6);
+    }
+    packageId(binding) {
+        return binding.templateIdLiteral.split(":")[0];
+    }
+    moduleName(binding) {
+        return binding.templateIdLiteral.split(":")[1];
+    }
+    entityName(binding) {
+        return binding.templateIdLiteral.split(":")[2];
+    }
+    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 relative = from.map(() => "..").concat(to).join("/") || ".";
+        return `${relative.startsWith(".") ? relative : `./${relative}`}`.replace(/\.ts$/, ".js");
     }
 }

package/dist/daml-interface/emission/type-script-name-resolver.d.ts

@@ -1,21 +1,68 @@
-import { DamlLfType } from "../../daml-lf/model/daml-lf-type.js";
 import { AnalyzedChoice } from "../analysis/analyzed-choice.js";
-import { AnalyzedTemplate } from "../analysis/analyzed-template.js";
+import { AnalyzedDamlType } from "../analysis/analyzed-daml-type.js";
+import { AnalyzedDamlTypeDefinition } from "../analysis/analyzed-daml-type-definition.js";
+import { AnalyzedTemplate, AnalyzedTemplateField } from "../analysis/analyzed-template.js";
 export declare class TypeScriptNameResolver {
+    private readonly templatesByIdentity;
+    private resolvedTemplates;
+    private resolvedModules;
+    constructor(templates?: readonly AnalyzedTemplate[]);
+    /** Prepares a project-wide name table and rejects irreconcilable output collisions. */
+    prepareTemplatesOrThrow(templates: readonly AnalyzedTemplate[]): void;
+    /** Prepares shared package/module paths for template and named DAML type output. */
+    prepareProjectOrThrow(templates: readonly AnalyzedTemplate[], typeDefinitions: readonly AnalyzedDamlTypeDefinition[]): void;
+    /** Resolves the full package/module/entity identity key for a template. */
+    getTemplateIdentityKey(template: AnalyzedTemplate): string;
+    /** Resolves the generated namespace alias for a template package/module. */
+    getNamespaceAlias(template: AnalyzedTemplate): string;
     /** Resolves the generated file path for a template binding. */
     getTemplateFilePath(template: AnalyzedTemplate): string;
+    /** Resolves the generated class name for a template binding. */
+    getTemplateClassName(template: AnalyzedTemplate): string;
+    /** Resolves the output directory shared by a named DAML type package/module. */
+    getNamedTypeModuleDirectoryPath(packageId: string, moduleName: string): string;
+    /** Resolves the generated namespace alias shared by templates and named DAML types. */
+    getNamedTypeModuleNamespaceAlias(packageId: string, moduleName: string): string;
     /** Resolves the generated create-fields type name for a template. */
     getCreateFieldsTypeName(template: AnalyzedTemplate): string;
     /** Resolves the generated created-event type name for a template. */
     getCreatedEventTypeName(template: AnalyzedTemplate): string;
+    /** Resolves the generated property name for an original DAML template field. */
+    getFieldPropertyName(template: AnalyzedTemplate, field: AnalyzedTemplateField): string;
+    /** Resolves the generated constructor parameter for an original DAML template field. */
+    getFieldConstructorParameterName(template: AnalyzedTemplate, field: AnalyzedTemplateField): string;
+    /** Resolves the generated exercise method name for a DAML choice. */
+    getChoiceMethodName(template: AnalyzedTemplate, choice: AnalyzedChoice): string;
     /** Resolves the generated choice payload type name for a template choice. */
     getChoiceTypeName(template: AnalyzedTemplate, choice: AnalyzedChoice): string;
     /** Resolves the generated exercised-event type name for a template choice. */
     getExercisedEventTypeName(template: AnalyzedTemplate, choice: AnalyzedChoice): string;
+    /** Resolves the generated parameter property name for a DAML choice. */
+    getChoiceParameterName(template: AnalyzedTemplate, choice: AnalyzedChoice): string;
+    /** Resolves the full identity key for a DAML choice. */
+    getChoiceIdentityKey(template: AnalyzedTemplate, choice: AnalyzedChoice): string;
     /** Resolves the TypeScript type name for a supported DAML-LF type. */
-    getTypeName(type: DamlLfType): string;
+    getTypeName(type: AnalyzedDamlType): string;
     /** Resolves the literal template identifier used by generated helpers. */
     getTemplateIdLiteral(template: AnalyzedTemplate): string;
+    private getResolvedTemplate;
+    private getResolvedModule;
+    private getResolvedField;
+    private getResolvedChoice;
+    private resolveFieldNames;
+    private resolveChoiceNames;
+    private resolveNames;
+    private assertDistinctTemplateOutput;
+    private assertDistinctNamespaceAliases;
     private getModuleDirectory;
+    private getTemplateFileBaseName;
+    private getPackageModuleIdentityKey;
+    private getPackageModuleIdentityKeyFromParts;
+    private safeTypeName;
+    private safeNamespaceAlias;
+    private safeMemberName;
+    private toPascalCase;
     private toKebabCase;
+    private shortHash;
+    private describeTemplate;
 }