@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.29

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

@@ -95,10 +95,10 @@ export class TemplateBindingEmitter {
             namedImports.set(reference.path, imported);
         }
         return [
-            'import { DamlMaterializationError, DamlTemplate, decodeDamlValue, materializeDamlValue, normalizeDamlCreatedEventSource, normalizeDamlExercisedEventSource } from "@distrohelena/canton-typescript-sdk/daml-interface";',
+            'import { DamlEventSourceNormalizer, DamlMaterializationError, DamlTemplate, DamlValueConverter, DamlValueMaterializer } 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)};`),
+            `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 === alias ? name : `${name} as ${alias}`).join(", ")} } from ${JSON.stringify(path)};`),
         ];
     }
     emitTemplateClass(binding, constructorParameters, constructorAssignments, orderedArguments, exercisedReturnType) {
@@ -115,9 +115,9 @@ export class TemplateBindingEmitter {
             "    }",
             "",
             `    public static fromCreatedEvent(event: DamlCreatedEventSource): ${binding.className} {`,
-            "        const normalized = normalizeDamlCreatedEventSource(event);",
+            "        const normalized = DamlEventSourceNormalizer.normalizeCreated(event);",
             `        ${binding.className}.assertTemplateIdentity(normalized.metadata.templateId);`,
-            `        const fields = materializeDamlValue<${binding.createFieldsTypeName}>(decodeDamlValue(normalized.payload, ${binding.className}.descriptor, generatedDamlTypeDescriptorRegistry, "create arguments"));`,
+            `        const fields = DamlValueMaterializer.materialize<${binding.createFieldsTypeName}>(DamlValueConverter.decode(normalized.payload, ${binding.className}.descriptor, GeneratedDamlTypeDescriptorRegistry, "create arguments"));`,
             `        return new ${binding.className}(`,
             "            normalized.contractId,",
             ...orderedArguments,
@@ -125,7 +125,7 @@ export class TemplateBindingEmitter {
             "    }",
             "",
             `    public static fromExercisedEvent(event: DamlExercisedEventSource): ${exercisedReturnType} {`,
-            "        const normalized = normalizeDamlExercisedEventSource(event);",
+            "        const normalized = DamlEventSourceNormalizer.normalizeExercised(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);`),
@@ -164,7 +164,7 @@ export class TemplateBindingEmitter {
             "    }",
             "",
             `    public static fromExercisedEvent(event: DamlExercisedEventSource): ${choice.exercisedEventTypeName} {`,
-            "        const normalized = normalizeDamlExercisedEventSource(event);",
+            "        const normalized = DamlEventSourceNormalizer.normalizeExercised(event);",
             `        ${choice.exercisedEventTypeName}.assertTemplateIdentity(normalized.metadata.templateId);`,
             `        return ${choice.exercisedEventTypeName}.fromNormalizedEvent(normalized);`,
             "    }",
@@ -174,8 +174,8 @@ export class TemplateBindingEmitter {
             `        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"));`,
+            `        const argument = DamlValueMaterializer.materialize<${choice.parameterTypeName}>(DamlValueConverter.decode(event.argument, ${choice.exercisedEventTypeName}.argumentDescriptor, GeneratedDamlTypeDescriptorRegistry, "choice argument"));`,
+            `        const result = DamlValueMaterializer.materialize<${choice.returnTypeName}>(DamlValueConverter.decode(event.result, ${choice.exercisedEventTypeName}.resultDescriptor, GeneratedDamlTypeDescriptorRegistry, "exercise result"));`,
             `        return new ${choice.exercisedEventTypeName}(event.contractId, argument, result, event.consuming, event.metadata);`,
             "    }",
             "",
@@ -210,8 +210,10 @@ export class TemplateBindingEmitter {
                 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 "typeVariable":
+                throw new Error("Cannot emit generic DAML type variables");
             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)).join(", ")}] }`;
         }
     }
     getTypeName(type, namedReferences) {
@@ -234,8 +236,14 @@ export class TemplateBindingEmitter {
                 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;
+            case "typeVariable":
+                throw new Error("Cannot emit generic DAML type variables");
+            case "namedReference": {
+                const name = this.getNamedReference(type.identity, namedReferences).alias;
+                return (type.typeArguments?.length ?? 0) === 0
+                    ? name
+                    : `${name}<${(type.typeArguments ?? []).map((argument) => this.getTypeName(argument, namedReferences)).join(", ")}>`;
+            }
         }
     }
     getPrimitiveTypeName(type) {
@@ -262,7 +270,14 @@ export class TemplateBindingEmitter {
             return { kind: "contractId" };
         }
         else if (type.typeConReference !== undefined) {
-            return { kind: "namedReference", identity: type.typeConReference };
+            if (type.typeArguments.length !== 0) {
+                throw new Error("Cannot emit generic DAML named type applications");
+            }
+            return {
+                kind: "namedReference",
+                identity: type.typeConReference,
+                typeArguments: [],
+            };
         }
         const arguments_ = type.typeArguments.map((argument) => this.normalizeType(argument));
         switch (type.builtinType) {
@@ -304,7 +319,26 @@ export class TemplateBindingEmitter {
         }
         const aliases = new Map();
         const usedAliases = new Set();
-        for (const [key, reference] of [...identities.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        const exportedNameCounts = new Map();
+        for (const [key, reference] of identities) {
+            const file = namedTypeFiles.find((candidate) => candidate.packageId === reference.identity.packageId
+                && candidate.moduleName === reference.identity.moduleName);
+            const exportedName = file?.exportedTypeNamesByIdentity.get(key);
+            if (exportedName !== undefined) {
+                exportedNameCounts.set(exportedName, (exportedNameCounts.get(exportedName) ?? 0) + 1);
+            }
+        }
+        for (const [key, reference] of [...identities.entries()].sort(([, left], [, right]) => {
+            const leftIsLocal = left.identity.packageId === template.templateId.packageId
+                && left.identity.moduleName === template.templateId.moduleName;
+            const rightIsLocal = right.identity.packageId === template.templateId.packageId
+                && right.identity.moduleName === template.templateId.moduleName;
+            if (leftIsLocal !== rightIsLocal) {
+                return leftIsLocal ? -1 : 1;
+            }
+            return this.getNamedReferenceKey(left.identity)
+                .localeCompare(this.getNamedReferenceKey(right.identity));
+        })) {
             const file = namedTypeFiles.find((candidate) => candidate.packageId === reference.identity.packageId
                 && candidate.moduleName === reference.identity.moduleName);
             const exportedName = file?.exportedTypeNamesByIdentity.get(key);
@@ -315,7 +349,11 @@ export class TemplateBindingEmitter {
                 aliases.set(key, reference.identity.name);
                 continue;
             }
-            const baseAlias = this.toTypeName(`${reference.identity.packageId} ${reference.identity.moduleName} ${exportedName}`);
+            const isLocal = reference.identity.packageId === template.templateId.packageId
+                && reference.identity.moduleName === template.templateId.moduleName;
+            const baseAlias = exportedNameCounts.get(exportedName) === 1 || isLocal
+                ? exportedName
+                : this.toTypeName(`${file.namespaceAlias} ${exportedName}`);
             let alias = baseAlias;
             let escalation = 2;
             while (usedAliases.has(alias)) {
@@ -348,6 +386,9 @@ export class TemplateBindingEmitter {
         switch (type.kind) {
             case "namedReference":
                 yield type;
+                for (const typeArgument of type.typeArguments ?? []) {
+                    yield* this.walkNamedReferences(typeArgument);
+                }
                 return;
             case "contractId": return;
             case "optional":
@@ -372,7 +413,8 @@ export class TemplateBindingEmitter {
                 }
                 return;
             case "primitive":
-            case "enum": return;
+            case "enum":
+            case "typeVariable": return;
         }
     }
     getNamedReference(identity, namedReferences) {

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

@@ -2,15 +2,17 @@ import { AnalyzedChoice } from "../analysis/analyzed-choice.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";
+import { DamlInterfacePackageMetadata } from "../analysis/daml-interface-analyzer.js";
 export declare class TypeScriptNameResolver {
     private readonly templatesByIdentity;
     private resolvedTemplates;
     private resolvedModules;
-    constructor(templates?: readonly AnalyzedTemplate[]);
+    private packageMetadata;
+    constructor(templates?: readonly AnalyzedTemplate[], packageMetadata?: ReadonlyMap<string, DamlInterfacePackageMetadata>);
     /** 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;
+    prepareProjectOrThrow(templates: readonly AnalyzedTemplate[], typeDefinitions: readonly AnalyzedDamlTypeDefinition[], packageMetadata?: ReadonlyMap<string, DamlInterfacePackageMetadata>): 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. */
@@ -55,6 +57,10 @@ export declare class TypeScriptNameResolver {
     private assertDistinctTemplateOutput;
     private assertDistinctNamespaceAliases;
     private getModuleDirectory;
+    private getPackageDirectoryBaseName;
+    private getPackageNamespaceLabel;
+    private toPackageNameSegment;
+    private toPackageVersionSegment;
     private getTemplateFileBaseName;
     private getPackageModuleIdentityKey;
     private getPackageModuleIdentityKeyFromParts;

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

@@ -17,18 +17,20 @@ export class TypeScriptNameResolver {
     templatesByIdentity = new Map();
     resolvedTemplates = new Map();
     resolvedModules = new Map();
-    constructor(templates = []) {
-        this.prepareTemplatesOrThrow(templates);
+    packageMetadata = new Map();
+    constructor(templates = [], packageMetadata = new Map()) {
+        this.prepareProjectOrThrow(templates, [], packageMetadata);
     }
     /** Prepares a project-wide name table and rejects irreconcilable output collisions. */
     prepareTemplatesOrThrow(templates) {
-        this.prepareProjectOrThrow(templates, []);
+        this.prepareProjectOrThrow(templates, [], this.packageMetadata);
     }
     /** Prepares shared package/module paths for template and named DAML type output. */
-    prepareProjectOrThrow(templates, typeDefinitions) {
+    prepareProjectOrThrow(templates, typeDefinitions, packageMetadata = new Map()) {
         this.templatesByIdentity.clear();
         this.resolvedTemplates.clear();
         this.resolvedModules.clear();
+        this.packageMetadata = new Map(packageMetadata);
         for (const template of templates) {
             const identityKey = this.getTemplateIdentityKey(template);
             const existing = this.templatesByIdentity.get(identityKey);
@@ -56,7 +58,7 @@ export class TypeScriptNameResolver {
         const packageDirectories = this.resolveNames(packageIds.map((packageId) => ({
             value: packageId,
             key: `package\u0000${packageId}`,
-            baseName: this.toKebabCase(packageId),
+            baseName: this.getPackageDirectoryBaseName(packageId),
             scope: "packages",
         })));
         const moduleDirectories = this.resolveNames([...modulesByIdentity.entries()].map(([identityKey, module]) => ({
@@ -74,7 +76,7 @@ export class TypeScriptNameResolver {
         const namespaceAliases = this.resolveNames([...modulesByIdentity.entries()].map(([identityKey, module]) => ({
             value: identityKey,
             key: `namespace\u0000${identityKey}`,
-            baseName: this.safeNamespaceAlias(`${module.packageId} ${module.moduleName}`),
+            baseName: this.safeNamespaceAlias(`${this.getPackageNamespaceLabel(module.packageId)} ${module.moduleName}`),
             collisionSeparator: "_",
         })));
         const classNames = this.resolveNames(allTemplates.map((template) => ({
@@ -336,6 +338,39 @@ export class TypeScriptNameResolver {
             .map((segment) => this.toKebabCase(segment))
             .join("/");
     }
+    getPackageDirectoryBaseName(packageId) {
+        const metadata = this.packageMetadata.get(packageId);
+        if (metadata === undefined
+            || metadata.packageName.trim().length === 0
+            || metadata.packageVersion.trim().length === 0) {
+            return this.toKebabCase(packageId);
+        }
+        return `${this.toPackageNameSegment(metadata.packageName)}_${this.toPackageVersionSegment(metadata.packageVersion)}`;
+    }
+    getPackageNamespaceLabel(packageId) {
+        const packageName = this.packageMetadata.get(packageId)?.packageName.trim();
+        return packageName === undefined || packageName.length === 0
+            ? packageId
+            : packageName;
+    }
+    toPackageNameSegment(value) {
+        const segment = value
+            .trim()
+            .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+            .replace(/[^A-Za-z0-9]+/g, "-")
+            .replace(/-+/g, "-")
+            .replace(/^-|-$/g, "")
+            .toLowerCase();
+        return segment.length === 0 ? "package" : segment;
+    }
+    toPackageVersionSegment(value) {
+        const segment = value
+            .trim()
+            .replace(/[^A-Za-z0-9._-]+/g, "-")
+            .replace(/-+/g, "-")
+            .replace(/^-|-$/g, "");
+        return segment.length === 0 ? "unknown" : segment;
+    }
     getTemplateFileBaseName(template) {
         const fileName = this.toKebabCase(template.templateId.templateName);
         return fileName === "index" || fileName === "types"

package/dist/daml-interface/index.d.ts

@@ -14,9 +14,9 @@ export { DamlInterfaceWriteException } from "./errors/daml-interface-write.excep
 export { DamlInterfaceWriter } from "./writing/daml-interface-writer.js";
 export { DamlTemplate } from "./runtime/daml-template.js";
 export { DamlMaterializationError } from "./runtime/daml-materialization-error.js";
-export { decodeDamlValue } from "./runtime/daml-value-converter.js";
-export { materializeDamlValue } from "./runtime/daml-value-materializer.js";
-export { normalizeDamlCreatedEventSource, normalizeDamlExercisedEventSource, } from "./runtime/daml-event-source-normalizer.js";
+export { DamlValueConverter } from "./runtime/daml-value-converter.js";
+export { DamlValueMaterializer } from "./runtime/daml-value-materializer.js";
+export { DamlEventSourceNormalizer } from "./runtime/daml-event-source-normalizer.js";
 export { DamlNumeric } from "../core/types/daml-numeric.js";
 export { DamlParty } from "../core/types/daml-party.js";
 export { DamlDate, DamlEnum, DamlGenMap, DamlRecord, DamlTextMap, DamlTimestamp, DamlUnit, DamlVariant, } from "../core/types/daml-values.js";

package/dist/daml-interface/index.js

@@ -14,9 +14,9 @@ export { DamlInterfaceWriteException } from "./errors/daml-interface-write.excep
 export { DamlInterfaceWriter } from "./writing/daml-interface-writer.js";
 export { DamlTemplate } from "./runtime/daml-template.js";
 export { DamlMaterializationError } from "./runtime/daml-materialization-error.js";
-export { decodeDamlValue } from "./runtime/daml-value-converter.js";
-export { materializeDamlValue } from "./runtime/daml-value-materializer.js";
-export { normalizeDamlCreatedEventSource, normalizeDamlExercisedEventSource, } from "./runtime/daml-event-source-normalizer.js";
+export { DamlValueConverter } from "./runtime/daml-value-converter.js";
+export { DamlValueMaterializer } from "./runtime/daml-value-materializer.js";
+export { DamlEventSourceNormalizer } from "./runtime/daml-event-source-normalizer.js";
 export { DamlNumeric } from "../core/types/daml-numeric.js";
 export { DamlParty } from "../core/types/daml-party.js";
 export { DamlDate, DamlEnum, DamlGenMap, DamlRecord, DamlTextMap, DamlTimestamp, DamlUnit, DamlVariant, } from "../core/types/daml-values.js";

package/dist/daml-interface/runtime/daml-event-source-normalizer.d.ts

@@ -39,14 +39,11 @@ export type DamlNormalizedExercisedEvent = {
     readonly consuming: boolean;
     readonly metadata: DamlExercisedEventMetadata;
 };
-/**
- * Recognizes a Ledger API create event, a contract response/wrapper, or a
- * PQS/JSON contract record and produces one immutable runtime shape.
- */
-export declare function normalizeDamlCreatedEventSource(source: DamlCreatedEventSource): DamlNormalizedCreatedEvent;
-/**
- * Recognizes a Ledger API exercise event or a PQS/JSON exercise record and
- * produces one immutable runtime shape. Choice information may be supplied by
- * PQS's exercise-type relation and identity by its contract relation.
- */
-export declare function normalizeDamlExercisedEventSource(source: DamlExercisedEventSource): DamlNormalizedExercisedEvent;
+/** Recognizes Ledger API and PQS event sources as immutable DAML event shapes. */
+export declare class DamlEventSourceNormalizer {
+    private constructor();
+    /** Recognizes a Ledger API create event, contract response/wrapper, or PQS/JSON contract record. */
+    static normalizeCreated(source: DamlCreatedEventSource): DamlNormalizedCreatedEvent;
+    /** Recognizes a Ledger API exercise event or a PQS/JSON exercise record. */
+    static normalizeExercised(source: DamlExercisedEventSource): DamlNormalizedExercisedEvent;
+}

package/dist/daml-interface/runtime/daml-event-source-normalizer.js

@@ -5,11 +5,19 @@ import { ActiveContract } from "../../transports/grpc/generated/canton/com/daml/
 import { DamlMaterializationError } from "./daml-materialization-error.js";
 const DAML_MIN_TIMESTAMP_SECONDS = -62135596800n;
 const DAML_MAX_TIMESTAMP_SECONDS = 253402300799n;
-/**
- * Recognizes a Ledger API create event, a contract response/wrapper, or a
- * PQS/JSON contract record and produces one immutable runtime shape.
- */
-export function normalizeDamlCreatedEventSource(source) {
+/** Recognizes Ledger API and PQS event sources as immutable DAML event shapes. */
+export class DamlEventSourceNormalizer {
+    constructor() { }
+    /** Recognizes a Ledger API create event, contract response/wrapper, or PQS/JSON contract record. */
+    static normalizeCreated(source) {
+        return normalizeDamlCreatedEventSource(source);
+    }
+    /** Recognizes a Ledger API exercise event or a PQS/JSON exercise record. */
+    static normalizeExercised(source) {
+        return normalizeDamlExercisedEventSource(source);
+    }
+}
+function normalizeDamlCreatedEventSource(source) {
     const recognized = findNestedEvent(source, "created");
     const { event } = recognized;
     const contractId = requiredString(event, ["contractId", "contract_id"], "contract ID", "created event source");
@@ -23,12 +31,7 @@ export function normalizeDamlCreatedEventSource(source) {
         metadata,
     });
 }
-/**
- * Recognizes a Ledger API exercise event or a PQS/JSON exercise record and
- * produces one immutable runtime shape. Choice information may be supplied by
- * PQS's exercise-type relation and identity by its contract relation.
- */
-export function normalizeDamlExercisedEventSource(source) {
+function normalizeDamlExercisedEventSource(source) {
     const recognized = findNestedEvent(source, "exercised");
     const { event } = recognized;
     const contractId = requiredString(event, ["contractId", "contract_id"], "contract ID", "exercised event source");

package/dist/daml-interface/runtime/daml-type-descriptor.d.ts

@@ -55,12 +55,13 @@ export type DamlEnumDescriptor = {
 export type DamlNamedReferenceDescriptor = {
     readonly kind: "namedReference";
     readonly identity: DamlTypeIdentity;
+    readonly typeArguments: readonly DamlTypeDescriptor[];
 };
 /** A closed description of a serializable DAML value. */
 export type DamlTypeDescriptor = DamlPrimitiveDescriptor | DamlContractIdDescriptor | DamlOptionalDescriptor | DamlListDescriptor | DamlTextMapDescriptor | DamlGenMapDescriptor | DamlRecordDescriptor | DamlVariantDescriptor | DamlEnumDescriptor | DamlNamedReferenceDescriptor;
 /** Resolves named descriptors lazily so recursive data types remain finite. */
 export type DamlTypeDescriptorRegistry = {
-    readonly resolve: (identity: DamlTypeIdentity) => (() => DamlTypeDescriptor) | undefined;
+    readonly resolve: (identity: DamlTypeIdentity, typeArguments: readonly DamlTypeDescriptor[]) => DamlTypeDescriptor | undefined;
 };
 export type DamlValueSource = {
     readonly kind: "protobuf";

package/dist/daml-interface/runtime/daml-value-converter.d.ts

@@ -3,5 +3,8 @@ import { DamlNumeric } from "../../core/types/daml-numeric.js";
 import { DamlParty } from "../../core/types/daml-party.js";
 import { DamlTypeDescriptor, DamlTypeDescriptorRegistry, DamlValueSource } from "./daml-type-descriptor.js";
 export type DamlDecodedValue = DamlUnit | boolean | bigint | DamlDate | DamlTimestamp | DamlNumeric | DamlParty | string | undefined | readonly DamlDecodedValue[] | DamlTextMap | DamlGenMap | DamlRecord | DamlVariant | DamlEnum;
-/** Decodes a protobuf or JSON/PQS DAML value according to its generated descriptor. */
-export declare function decodeDamlValue(source: DamlValueSource, descriptor: DamlTypeDescriptor, registry: DamlTypeDescriptorRegistry, path: string): DamlDecodedValue;
+/** Decodes protobuf or JSON/PQS DAML values according to generated descriptors. */
+export declare class DamlValueConverter {
+    private constructor();
+    static decode(source: DamlValueSource, descriptor: DamlTypeDescriptor, registry: DamlTypeDescriptorRegistry, path: string): DamlDecodedValue;
+}

package/dist/daml-interface/runtime/daml-value-converter.js

@@ -8,14 +8,20 @@ const DAML_MIN_TIMESTAMP_MICROSECONDS = -62135596800000000n;
 const DAML_MAX_TIMESTAMP_MICROSECONDS = 253402300799999999n;
 const DAML_MIN_INT64 = -9223372036854775808n;
 const DAML_MAX_INT64 = 9223372036854775807n;
-/** Decodes a protobuf or JSON/PQS DAML value according to its generated descriptor. */
-export function decodeDamlValue(source, descriptor, registry, path) {
+/** Decodes protobuf or JSON/PQS DAML values according to generated descriptors. */
+export class DamlValueConverter {
+    constructor() { }
+    static decode(source, descriptor, registry, path) {
+        return decodeDamlValue(source, descriptor, registry, path);
+    }
+}
+function decodeDamlValue(source, descriptor, registry, path) {
     if (descriptor.kind === "namedReference") {
-        const factory = registry.resolve(descriptor.identity);
-        if (factory === undefined) {
+        const resolved = registry.resolve(descriptor.identity, descriptor.typeArguments);
+        if (resolved === undefined) {
             throw materializationError(path, "named type descriptor is not registered");
         }
-        return decodeDamlValue(source, factory(), registry, path);
+        return decodeDamlValue(source, resolved, registry, path);
     }
     else if (source.kind === "protobuf") {
         return decodeProtobufValue(source.value, descriptor, registry, path);

package/dist/daml-interface/runtime/daml-value-materializer.d.ts

@@ -1,3 +1,6 @@
 import { DamlDecodedValue } from "./daml-value-converter.js";
 /** Converts decoded DAML containers into the shapes exposed by generated TypeScript declarations. */
-export declare function materializeDamlValue<T>(value: DamlDecodedValue): T;
+export declare class DamlValueMaterializer {
+    private constructor();
+    static materialize<T>(value: DamlDecodedValue): T;
+}

package/dist/daml-interface/runtime/daml-value-materializer.js

@@ -1,6 +1,12 @@
 import { DamlEnum, DamlGenMap, DamlRecord, DamlTextMap, DamlVariant, } from "../../core/types/daml-values.js";
 /** Converts decoded DAML containers into the shapes exposed by generated TypeScript declarations. */
-export function materializeDamlValue(value) {
+export class DamlValueMaterializer {
+    constructor() { }
+    static materialize(value) {
+        return materializeDamlValue(value);
+    }
+}
+function materializeDamlValue(value) {
     return materialize(value);
 }
 function materialize(value) {

package/dist/daml-lf/daml-lf-compilation.d.ts

@@ -1,5 +1,6 @@
 import { DamlLfChoice } from "./model/daml-lf-choice.js";
 import { DamlLfModule } from "./model/daml-lf-module.js";
+import { DamlLfPackage } from "./model/daml-lf-package.js";
 import { DamlLfTemplate } from "./model/daml-lf-template.js";
 import { DamlLfTemplateId } from "./model/daml-lf-template-id.js";
 import { DamlLfValueDefinition } from "./model/daml-lf-value-definition.js";
@@ -30,6 +31,8 @@ export declare class DamlLfCompilation {
         definitionName: string;
     };
     getTemplates(): readonly DamlLfTemplate[];
+    /** Returns the packages available to this compilation. */
+    getPackages(): readonly DamlLfPackage[];
     getTemplateChoicesOrThrow(templateId: DamlLfTemplateId): readonly DamlLfChoice[];
     private buildIndexes;
     private validateReferencesOrThrow;

package/dist/daml-lf/daml-lf-compilation.js

@@ -70,6 +70,10 @@ export class DamlLfCompilation {
     getTemplates() {
         return [...this.templates.values()];
     }
+    /** Returns the packages available to this compilation. */
+    getPackages() {
+        return this.workspace.packages;
+    }
     getTemplateChoicesOrThrow(templateId) {
         return this.getTemplateOrThrow(templateId).choices;
     }

package/dist/daml-lf/model/daml-lf-data-type.d.ts

@@ -2,6 +2,23 @@ import { DamlLfDefinition } from "./daml-lf-definition.js";
 import { DamlLfField } from "./daml-lf-field.js";
 import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
 import { DamlLfType } from "./daml-lf-type.js";
+export type DamlLfTypeParameterKind = {
+    readonly kind: "star";
+} | {
+    readonly kind: "nat";
+} | {
+    readonly kind: "arrow";
+    readonly parameters: readonly DamlLfTypeParameterKind[];
+    readonly result: DamlLfTypeParameterKind;
+} | {
+    readonly kind: "unknown";
+    readonly internedKindIndex?: number;
+};
+export interface DamlLfTypeParameter {
+    readonly name?: string;
+    readonly internedStringIndex: number;
+    readonly kind: DamlLfTypeParameterKind;
+}
 export type DamlLfDataTypeDefinition = {
     readonly kind: "record";
     readonly fields: readonly DamlLfField[];
@@ -20,9 +37,11 @@ export declare class DamlLfDataType extends DamlLfDefinition {
     readonly nodeKind = DamlLfNodeKind.dataType;
     readonly definition: DamlLfDataTypeDefinition;
     readonly fields: readonly DamlLfField[];
+    readonly typeParameters: readonly DamlLfTypeParameter[];
     constructor(init: {
         name: string;
         definition?: DamlLfDataTypeDefinition;
         fields?: readonly DamlLfField[];
+        typeParameters?: readonly DamlLfTypeParameter[];
     });
 }

package/dist/daml-lf/model/daml-lf-data-type.js

@@ -4,6 +4,7 @@ export class DamlLfDataType extends DamlLfDefinition {
     nodeKind = DamlLfNodeKind.dataType;
     definition;
     fields;
+    typeParameters;
     constructor(init) {
         super({
             name: init.name,
@@ -15,5 +16,19 @@ export class DamlLfDataType extends DamlLfDefinition {
         this.fields = this.definition.kind === "record"
             ? this.definition.fields
             : [];
+        this.typeParameters = Object.freeze((init.typeParameters ?? []).map((parameter) => Object.freeze({
+            ...parameter,
+            kind: freezeTypeParameterKind(parameter.kind),
+        })));
     }
 }
+function freezeTypeParameterKind(kind) {
+    if (kind.kind !== "arrow") {
+        return Object.freeze({ ...kind });
+    }
+    return Object.freeze({
+        kind: "arrow",
+        parameters: Object.freeze(kind.parameters.map((parameter) => freezeTypeParameterKind(parameter))),
+        result: freezeTypeParameterKind(kind.result),
+    });
+}

package/dist/daml-lf/model/daml-lf-type.d.ts

@@ -1,16 +1,29 @@
 import { DamlLfBuiltinType } from "./daml-lf-builtin-type.js";
+import { DamlLfTypeParameter } from "./daml-lf-data-type.js";
 import { DamlLfNodeKind } from "./daml-lf-node-kind.js";
 import { TypeConReference } from "./type-con-reference.js";
+export interface DamlLfTypeVariableReference {
+    readonly name?: string;
+    readonly internedStringIndex: number;
+}
+export interface DamlLfDiagnosticForall {
+    readonly typeParameters: readonly DamlLfTypeParameter[];
+    readonly body: DamlLfType;
+}
 export declare class DamlLfType {
     readonly nodeKind = DamlLfNodeKind.type;
     readonly builtinType: DamlLfBuiltinType;
     readonly numericScale?: number;
     readonly typeConReference?: TypeConReference;
+    readonly typeVariable?: DamlLfTypeVariableReference;
+    readonly diagnosticForall?: DamlLfDiagnosticForall;
     readonly typeArguments: readonly DamlLfType[];
     constructor(init: {
         builtinType?: DamlLfBuiltinType;
         numericScale?: number;
         typeConReference?: TypeConReference;
+        typeVariable?: DamlLfTypeVariableReference;
+        diagnosticForall?: DamlLfDiagnosticForall;
         typeArguments?: readonly DamlLfType[];
     });
 }

package/dist/daml-lf/model/daml-lf-type.js

@@ -5,6 +5,8 @@ export class DamlLfType {
     builtinType;
     numericScale;
     typeConReference;
+    typeVariable;
+    diagnosticForall;
     typeArguments;
     constructor(init) {
         this.builtinType = init.builtinType ?? DamlLfBuiltinType.unknown;
@@ -12,6 +14,28 @@ export class DamlLfType {
             this.numericScale = init.numericScale;
         }
         this.typeConReference = init.typeConReference;
+        this.typeVariable = init.typeVariable === undefined
+            ? undefined
+            : Object.freeze({ ...init.typeVariable });
+        this.diagnosticForall = init.diagnosticForall === undefined
+            ? undefined
+            : Object.freeze({
+                typeParameters: Object.freeze(init.diagnosticForall.typeParameters.map((parameter) => Object.freeze({
+                    ...parameter,
+                    kind: freezeTypeParameterKind(parameter.kind),
+                }))),
+                body: init.diagnosticForall.body,
+            });
         this.typeArguments = Object.freeze([...(init.typeArguments ?? [])]);
     }
 }
+function freezeTypeParameterKind(kind) {
+    if (kind.kind !== "arrow") {
+        return Object.freeze({ ...kind });
+    }
+    return Object.freeze({
+        kind: "arrow",
+        parameters: Object.freeze(kind.parameters.map((parameter) => freezeTypeParameterKind(parameter))),
+        result: freezeTypeParameterKind(kind.result),
+    });
+}

package/dist/daml-lf/model/lf-2-model-mapper.d.ts

@@ -4,6 +4,9 @@ import { DamlLfPackage } from "./daml-lf-package.js";
 export declare class Lf2ModelMapper {
     static mapPackage(packageId: string, rawPackage: LfArchivePackage, languageVersion: DamlLfLanguageVersion): DamlLfPackage;
     private static mapType;
+    private static mapTypeParameter;
+    private static mapTypeVariableReference;
+    private static mapTypeParameterKind;
     private static mapBuiltinType;
     private static readNumericScale;
     private static mapModule;
@@ -21,5 +24,6 @@ export declare class Lf2ModelMapper {
     private static mapUpdateExpression;
     private static mapTemplateReferenceOrThrow;
     private static resolveInternedString;
+    private static resolveInternedStringOrUndefined;
     private static resolveInternedDottedName;
 }