@distrohelena/canton-typescript-sdk 0.1.28 → 0.1.30

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

@@ -0,0 +1,380 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlValueConverter = void 0;
+const daml_values_js_1 = require("../../core/types/daml-values.js");
+const daml_numeric_js_1 = require("../../core/types/daml-numeric.js");
+const daml_party_js_1 = require("../../core/types/daml-party.js");
+const daml_materialization_error_js_1 = require("./daml-materialization-error.js");
+const DAML_MIN_DATE_DAYS_SINCE_EPOCH = -719162;
+const DAML_MAX_DATE_DAYS_SINCE_EPOCH = 2932896;
+const DAML_MIN_TIMESTAMP_MICROSECONDS = -62135596800000000n;
+const DAML_MAX_TIMESTAMP_MICROSECONDS = 253402300799999999n;
+const DAML_MIN_INT64 = -9223372036854775808n;
+const DAML_MAX_INT64 = 9223372036854775807n;
+/** Decodes protobuf or JSON/PQS DAML values according to generated descriptors. */
+class DamlValueConverter {
+    constructor() { }
+    static decode(source, descriptor, registry, path) {
+        return decodeDamlValue(source, descriptor, registry, path);
+    }
+}
+exports.DamlValueConverter = DamlValueConverter;
+function decodeDamlValue(source, descriptor, registry, path) {
+    if (descriptor.kind === "namedReference") {
+        const resolved = registry.resolve(descriptor.identity, descriptor.typeArguments);
+        if (resolved === undefined) {
+            throw materializationError(path, "named type descriptor is not registered");
+        }
+        return decodeDamlValue(source, resolved, registry, path);
+    }
+    else if (source.kind === "protobuf") {
+        return decodeProtobufValue(source.value, descriptor, registry, path);
+    }
+    return decodeJsonValue(source.value, descriptor, registry, path);
+}
+function decodeProtobufValue(value, descriptor, registry, path) {
+    switch (value.sum.oneofKind) {
+        case undefined:
+            throw materializationError(path, "value is absent");
+        case "unit":
+            requirePrimitiveDescriptor(descriptor, "unit", path);
+            return new daml_values_js_1.DamlUnit();
+        case "bool":
+            requirePrimitiveDescriptor(descriptor, "bool", path);
+            return value.sum.bool;
+        case "int64":
+            requirePrimitiveDescriptor(descriptor, "int64", path);
+            return decodeInt64(value.sum.int64, path);
+        case "date":
+            requirePrimitiveDescriptor(descriptor, "date", path);
+            return decodeDate(value.sum.date, path);
+        case "timestamp":
+            requirePrimitiveDescriptor(descriptor, "timestamp", path);
+            return decodeTimestamp(value.sum.timestamp, path);
+        case "numeric":
+            requirePrimitiveDescriptor(descriptor, "numeric", path);
+            return decodeNumeric(value.sum.numeric, descriptor.numericScale, path);
+        case "party":
+            requirePrimitiveDescriptor(descriptor, "party", path);
+            return decodeParty(value.sum.party, path);
+        case "text":
+            requirePrimitiveDescriptor(descriptor, "text", path);
+            return value.sum.text;
+        case "contractId":
+            requireDescriptorKind(descriptor, "contractId", path, "contractId");
+            return value.sum.contractId;
+        case "optional":
+            requireDescriptorKind(descriptor, "optional", path, "optional");
+            return value.sum.optional.value === undefined
+                ? undefined
+                : decodeDamlValue({ kind: "protobuf", value: value.sum.optional.value }, descriptor.element, registry, path);
+        case "list":
+            requireDescriptorKind(descriptor, "list", path, "list");
+            return value.sum.list.elements.map((element, index) => decodeDamlValue({ kind: "protobuf", value: element }, descriptor.element, registry, indexedPath(path, index)));
+        case "textMap":
+            requireDescriptorKind(descriptor, "textMap", path, "textMap");
+            return new daml_values_js_1.DamlTextMap(value.sum.textMap.entries.map((entry, index) => [
+                entry.key,
+                decodeRequiredProtobufValue(entry.value, descriptor.value, registry, `${indexedPath(path, index)}.${entry.key}`),
+            ]));
+        case "genMap":
+            requireDescriptorKind(descriptor, "genMap", path, "genMap");
+            return new daml_values_js_1.DamlGenMap(value.sum.genMap.entries.map((entry, index) => [
+                decodeRequiredProtobufValue(entry.key, descriptor.key, registry, `${indexedPath(path, index)}.key`),
+                decodeRequiredProtobufValue(entry.value, descriptor.value, registry, `${indexedPath(path, index)}.value`),
+            ]));
+        case "record":
+            requireDescriptorKind(descriptor, "record", path, "record");
+            return decodeProtobufRecord(value.sum.record, descriptor, registry, path);
+        case "variant": {
+            requireDescriptorKind(descriptor, "variant", path, "variant");
+            const variant = value.sum.variant;
+            const constructor = descriptor.constructors.find((candidate) => candidate.constructor === variant.constructor);
+            if (constructor === undefined) {
+                throw materializationError(path, `unknown variant constructor ${variant.constructor}`);
+            }
+            return new daml_values_js_1.DamlVariant(variant.constructor, decodeRequiredProtobufValue(variant.value, constructor.payload, registry, `${path}.${variant.constructor}`));
+        }
+        case "enum":
+            requireDescriptorKind(descriptor, "enum", path, "enum");
+            if (!descriptor.constructors.includes(value.sum.enum.constructor)) {
+                throw materializationError(path, `unknown enum constructor ${value.sum.enum.constructor}`);
+            }
+            return new daml_values_js_1.DamlEnum(value.sum.enum.constructor);
+        default:
+            return rejectUnknownProtobufKind(path, value.sum);
+    }
+}
+function decodeProtobufRecord(record, descriptor, registry, path) {
+    const fields = record.fields;
+    const labelsPresent = fields.every((field) => field.label.length > 0);
+    const labelsAbsent = fields.every((field) => field.label.length === 0);
+    if (!labelsPresent && !labelsAbsent) {
+        throw materializationError(path, "record fields mix labelled and positional encodings");
+    }
+    const output = Object.create(null);
+    if (labelsPresent) {
+        if (new Set(fields.map((field) => field.label)).size !== fields.length) {
+            throw materializationError(path, "record contains duplicate field labels");
+        }
+        for (const field of descriptor.fields) {
+            const sourceField = fields.find((candidate) => candidate.label === field.damlLabel);
+            if (sourceField === undefined) {
+                throw materializationError(fieldPath(path, field.propertyName), "required record field is absent");
+            }
+            output[field.propertyName] = decodeRequiredProtobufValue(sourceField.value, field.type, registry, fieldPath(path, field.propertyName));
+        }
+        if (fields.length !== descriptor.fields.length) {
+            throw materializationError(path, "record contains an unexpected field");
+        }
+    }
+    else {
+        if (fields.length !== descriptor.fields.length) {
+            throw materializationError(path, "record has the wrong number of positional fields");
+        }
+        descriptor.fields.forEach((field, index) => {
+            output[field.propertyName] = decodeRequiredProtobufValue(fields[index]?.value, field.type, registry, fieldPath(path, field.propertyName));
+        });
+    }
+    return new daml_values_js_1.DamlRecord(output);
+}
+function decodeJsonValue(value, descriptor, registry, path) {
+    switch (descriptor.kind) {
+        case "primitive":
+            return decodeJsonPrimitive(value, descriptor, path);
+        case "contractId":
+            return requireString(value, path, "contract ID");
+        case "optional":
+            return value === null ? undefined : decodeDamlValue({ kind: "json", value }, descriptor.element, registry, path);
+        case "list":
+            return requireArray(value, path, "list").map((element, index) => decodeDamlValue({ kind: "json", value: element }, descriptor.element, registry, indexedPath(path, index)));
+        case "textMap":
+            return decodeJsonTextMap(value, descriptor, registry, path);
+        case "genMap":
+            return new daml_values_js_1.DamlGenMap(requireArray(value, path, "generic map").map((entry, index) => {
+                const pair = requireArray(entry, indexedPath(path, index), "generic map entry");
+                if (pair.length !== 2) {
+                    throw materializationError(indexedPath(path, index), "generic map entries must contain key and value");
+                }
+                return [
+                    decodeDamlValue({ kind: "json", value: pair[0] }, descriptor.key, registry, `${indexedPath(path, index)}.key`),
+                    decodeDamlValue({ kind: "json", value: pair[1] }, descriptor.value, registry, `${indexedPath(path, index)}.value`),
+                ];
+            }));
+        case "record":
+            return decodeJsonRecord(value, descriptor, registry, path);
+        case "variant":
+            return decodeJsonVariant(value, descriptor, registry, path);
+        case "enum": {
+            const constructor = requireString(value, path, "enum constructor");
+            if (!descriptor.constructors.includes(constructor)) {
+                throw materializationError(path, `unknown enum constructor ${constructor}`);
+            }
+            return new daml_values_js_1.DamlEnum(constructor);
+        }
+    }
+}
+function decodeJsonPrimitive(value, descriptor, path) {
+    switch (descriptor.primitive) {
+        case "unit": {
+            const record = requireObject(value, path, "unit");
+            if (Object.keys(record).length !== 0) {
+                throw materializationError(path, "unit must be an empty object");
+            }
+            return new daml_values_js_1.DamlUnit();
+        }
+        case "bool":
+            if (typeof value !== "boolean") {
+                throw materializationError(path, "expected boolean");
+            }
+            return value;
+        case "int64":
+            return decodeInt64(requireString(value, path, "int64"), path);
+        case "date":
+            return decodeDate(value, path);
+        case "timestamp":
+            return decodeTimestamp(value, path);
+        case "numeric":
+            return decodeNumeric(requireString(value, path, "numeric"), descriptor.numericScale, path);
+        case "party":
+            return decodeParty(requireString(value, path, "party"), path);
+        case "text":
+            return requireString(value, path, "text");
+    }
+}
+function decodeJsonTextMap(value, descriptor, registry, path) {
+    const record = requireObject(value, path, "text map");
+    return new daml_values_js_1.DamlTextMap(objectEntries(record).map(([key, entryValue]) => [
+        key,
+        decodeDamlValue({ kind: "json", value: entryValue }, descriptor.value, registry, fieldPath(path, key)),
+    ]));
+}
+function decodeJsonRecord(value, descriptor, registry, path) {
+    const output = Object.create(null);
+    if (Array.isArray(value)) {
+        if (value.length !== descriptor.fields.length) {
+            throw materializationError(path, "record has the wrong number of positional fields");
+        }
+        descriptor.fields.forEach((field, index) => {
+            output[field.propertyName] = decodeDamlValue({ kind: "json", value: value[index] }, field.type, registry, fieldPath(path, field.propertyName));
+        });
+        return new daml_values_js_1.DamlRecord(output);
+    }
+    const record = requireObject(value, path, "record");
+    const expectedLabels = new Set(descriptor.fields.map((field) => field.damlLabel));
+    for (const [label] of objectEntries(record)) {
+        if (!expectedLabels.has(label)) {
+            throw materializationError(path, `record contains unexpected field ${label}`);
+        }
+    }
+    for (const field of descriptor.fields) {
+        if (!Object.hasOwn(record, field.damlLabel)) {
+            throw materializationError(fieldPath(path, field.propertyName), "required record field is absent");
+        }
+        output[field.propertyName] = decodeDamlValue({ kind: "json", value: Reflect.get(record, field.damlLabel) }, field.type, registry, fieldPath(path, field.propertyName));
+    }
+    return new daml_values_js_1.DamlRecord(output);
+}
+function decodeJsonVariant(value, descriptor, registry, path) {
+    const envelope = requireObject(value, path, "variant");
+    const tag = requireString(Reflect.get(envelope, "tag"), path, "variant tag");
+    const constructor = descriptor.constructors.find((candidate) => candidate.constructor === tag);
+    if (constructor === undefined) {
+        throw materializationError(path, `unknown variant constructor ${tag}`);
+    }
+    else if (!Object.hasOwn(envelope, "value")) {
+        throw materializationError(path, "variant value is absent");
+    }
+    return new daml_values_js_1.DamlVariant(tag, decodeDamlValue({ kind: "json", value: Reflect.get(envelope, "value") }, constructor.payload, registry, `${path}.${tag}`));
+}
+function decodeRequiredProtobufValue(value, descriptor, registry, path) {
+    if (value === undefined) {
+        throw materializationError(path, "required value is absent");
+    }
+    return decodeDamlValue({ kind: "protobuf", value }, descriptor, registry, path);
+}
+function requirePrimitiveDescriptor(descriptor, primitive, path) {
+    if (descriptor.kind !== "primitive" || descriptor.primitive !== primitive) {
+        throw materializationError(path, `expected ${descriptor.kind} but received ${primitive}`);
+    }
+}
+function requireDescriptorKind(descriptor, expected, path, received) {
+    if (descriptor.kind !== expected) {
+        throw materializationError(path, `expected ${descriptor.kind} but received ${received}`);
+    }
+}
+function rejectUnknownProtobufKind(path, _value) {
+    throw materializationError(path, "value has an unknown protobuf oneof kind");
+}
+function requireArray(value, path, description) {
+    if (!Array.isArray(value)) {
+        throw materializationError(path, `expected ${description} array`);
+    }
+    return value;
+}
+function requireObject(value, path, description) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw materializationError(path, `expected ${description} object`);
+    }
+    return value;
+}
+function requireString(value, path, description) {
+    if (typeof value !== "string") {
+        throw materializationError(path, `expected ${description} string`);
+    }
+    return value;
+}
+function requireIntegerString(value, path, description) {
+    const result = requireString(value, path, description);
+    if (!/^-?(?:0|[1-9]\d*)$/.test(result)) {
+        throw materializationError(path, `expected ${description} integer string`);
+    }
+    return result;
+}
+function decodeInt64(value, path) {
+    const integer = requireIntegerString(value, path, "int64");
+    let int64;
+    try {
+        int64 = BigInt(integer);
+    }
+    catch {
+        throw materializationError(path, "invalid int64");
+    }
+    if (int64 < DAML_MIN_INT64 || int64 > DAML_MAX_INT64) {
+        throw materializationError(path, "int64 is outside the DAML ledger range");
+    }
+    return int64;
+}
+function decodeDate(value, path) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+        throw materializationError(path, "expected integer date");
+    }
+    else if (value < DAML_MIN_DATE_DAYS_SINCE_EPOCH || value > DAML_MAX_DATE_DAYS_SINCE_EPOCH) {
+        throw materializationError(path, "date is outside the DAML ledger range");
+    }
+    return new daml_values_js_1.DamlDate(value);
+}
+function decodeTimestamp(value, path) {
+    const microseconds = requireIntegerString(value, path, "timestamp");
+    const timestamp = BigInt(microseconds);
+    if (timestamp < DAML_MIN_TIMESTAMP_MICROSECONDS || timestamp > DAML_MAX_TIMESTAMP_MICROSECONDS) {
+        throw materializationError(path, "timestamp is outside the DAML ledger range");
+    }
+    return new daml_values_js_1.DamlTimestamp(microseconds);
+}
+function decodeNumeric(value, numericScale, path) {
+    if (!/^[+-]?\d+(?:\.\d*)?$/.test(value)) {
+        throw materializationError(path, "invalid numeric");
+    }
+    const decimalSeparator = value.indexOf(".");
+    const fractionLength = decimalSeparator === -1 ? 0 : value.length - decimalSeparator - 1;
+    const precision = value.replace(/[+-.]/g, "").length;
+    const maxScale = numericScale ?? 37;
+    if (!Number.isInteger(maxScale) || maxScale < 0 || maxScale > 37) {
+        throw materializationError(path, "numeric descriptor has an invalid scale");
+    }
+    else if (precision > 38) {
+        throw materializationError(path, "numeric exceeds DAML ledger precision");
+    }
+    else if (fractionLength > maxScale) {
+        throw materializationError(path, "numeric exceeds its DAML scale");
+    }
+    try {
+        return new daml_numeric_js_1.DamlNumeric(canonicalizeLedgerNumeric(value));
+    }
+    catch {
+        throw materializationError(path, "invalid numeric");
+    }
+}
+function canonicalizeLedgerNumeric(value) {
+    const negative = value.startsWith("-");
+    const unsigned = value.startsWith("+") || negative ? value.slice(1) : value;
+    const decimalSeparator = unsigned.indexOf(".");
+    const integerPart = decimalSeparator === -1 ? unsigned : unsigned.slice(0, decimalSeparator);
+    const fractionPart = decimalSeparator === -1 ? "" : unsigned.slice(decimalSeparator + 1);
+    const canonicalIntegerPart = integerPart.replace(/^0+/, "") || "0";
+    const sign = negative ? "-" : "";
+    return fractionPart.length === 0
+        ? `${sign}${canonicalIntegerPart}`
+        : `${sign}${canonicalIntegerPart}.${fractionPart}`;
+}
+function decodeParty(value, path) {
+    try {
+        return new daml_party_js_1.DamlParty(value);
+    }
+    catch {
+        throw materializationError(path, "invalid party");
+    }
+}
+function objectEntries(record) {
+    return Object.keys(record).map((key) => [key, Reflect.get(record, key)]);
+}
+function fieldPath(path, propertyName) {
+    return `${path}.${propertyName}`;
+}
+function indexedPath(path, index) {
+    return `${path}[${index}]`;
+}
+function materializationError(path, detail) {
+    return new daml_materialization_error_js_1.DamlMaterializationError(path, detail);
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlValueMaterializer = void 0;
+const daml_values_js_1 = require("../../core/types/daml-values.js");
+/** Converts decoded DAML containers into the shapes exposed by generated TypeScript declarations. */
+class DamlValueMaterializer {
+    constructor() { }
+    static materialize(value) {
+        return materializeDamlValue(value);
+    }
+}
+exports.DamlValueMaterializer = DamlValueMaterializer;
+function materializeDamlValue(value) {
+    return materialize(value);
+}
+function materialize(value) {
+    if (value instanceof daml_values_js_1.DamlRecord) {
+        return Object.fromEntries(Object.entries(value.fields).map(([name, field]) => [name, materialize(field)]));
+    }
+    else if (value instanceof daml_values_js_1.DamlVariant) {
+        return Object.freeze({ tag: value.constructorName, value: materialize(value.value) });
+    }
+    else if (value instanceof daml_values_js_1.DamlEnum) {
+        return value.constructorName;
+    }
+    else if (value instanceof daml_values_js_1.DamlTextMap || value instanceof daml_values_js_1.DamlGenMap) {
+        return new Map(value.entries.map(([key, entry]) => [materialize(key), materialize(entry)]));
+    }
+    else if (Array.isArray(value)) {
+        return value.map((element) => materialize(element));
+    }
+    return value;
+}

package/dist/cjs/daml-interface/writing/daml-interface-writer.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DamlInterfaceWriter = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+class DamlInterfaceWriter {
+    /** Writes a generated in-memory project to the requested output directory. */
+    async writeProjectAsync(project, outputDirectory) {
+        const files = [
+            ...project.productionFiles,
+            ...project.specFiles,
+        ];
+        for (const file of files) {
+            const path = (0, node_path_1.join)(outputDirectory, file.path);
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(path), {
+                recursive: true,
+            });
+            await (0, promises_1.writeFile)(path, file.contents, "utf8");
+        }
+    }
+}
+exports.DamlInterfaceWriter = DamlInterfaceWriter;

package/dist/cjs/daml-lf/container/dar-archive-entry.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DarArchiveEntry = void 0;
+class DarArchiveEntry {
+    path;
+    bytes;
+    constructor(init) {
+        this.path = init.path;
+        this.bytes = init.bytes;
+    }
+}
+exports.DarArchiveEntry = DarArchiveEntry;

package/dist/cjs/daml-lf/container/dar-archive-loader.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DarArchiveLoader = void 0;
+const fflate_1 = require("fflate");
+const daml_lf_archive_exception_js_1 = require("../errors/daml-lf-archive.exception.js");
+const dar_archive_js_1 = require("./dar-archive.js");
+const dar_archive_entry_js_1 = require("./dar-archive-entry.js");
+const dar_manifest_js_1 = require("./dar-manifest.js");
+const dar_package_entry_js_1 = require("./dar-package-entry.js");
+const dar_source_file_entry_js_1 = require("./dar-source-file-entry.js");
+class DarArchiveLoader {
+    async loadDarOrThrowAsync(archiveBytes) {
+        try {
+            const archiveEntries = (0, fflate_1.unzipSync)(archiveBytes);
+            const manifestBytes = archiveEntries["META-INF/MANIFEST.MF"];
+            if (manifestBytes === undefined) {
+                throw new daml_lf_archive_exception_js_1.DamlLfArchiveException("dar archive does not contain META-INF/MANIFEST.MF");
+            }
+            const manifest = this.parseManifestOrThrow((0, fflate_1.strFromU8)(manifestBytes));
+            const entries = Object.entries(archiveEntries).map(([path, bytes]) => new dar_archive_entry_js_1.DarArchiveEntry({
+                path,
+                bytes,
+            }));
+            const packageEntries = Object.entries(archiveEntries)
+                .filter(([path]) => path.endsWith(".dalf"))
+                .map(([path, bytes]) => new dar_package_entry_js_1.DarPackageEntry({
+                path,
+                bytes,
+            }));
+            const sourceFiles = Object.entries(archiveEntries)
+                .filter(([path]) => path.endsWith(".daml"))
+                .map(([path, bytes]) => new dar_source_file_entry_js_1.DarSourceFileEntry({
+                path,
+                content: (0, fflate_1.strFromU8)(bytes),
+            }));
+            const mainPackageEntry = packageEntries.find((entry) => entry.path === manifest.mainDalfPath);
+            if (mainPackageEntry === undefined) {
+                throw new daml_lf_archive_exception_js_1.DamlLfArchiveException(`dar archive does not contain the main dalf entry '${manifest.mainDalfPath}'`);
+            }
+            return new dar_archive_js_1.DarArchive({
+                entries,
+                manifest,
+                mainPackageEntry,
+                packageEntries,
+                sourceFiles,
+            });
+        }
+        catch (error) {
+            if (error instanceof daml_lf_archive_exception_js_1.DamlLfArchiveException) {
+                throw error;
+            }
+            throw new daml_lf_archive_exception_js_1.DamlLfArchiveException(error instanceof Error
+                ? error.message
+                : "failed to read dar archive");
+        }
+    }
+    parseManifestOrThrow(manifestText) {
+        const properties = new Map();
+        let currentKey;
+        for (const rawLine of manifestText.split(/\r?\n/)) {
+            if (rawLine.startsWith(" ") && currentKey !== undefined) {
+                const currentValue = properties.get(currentKey) ?? "";
+                properties.set(currentKey, `${currentValue}${rawLine.slice(1)}`);
+                continue;
+            }
+            const line = rawLine.trim();
+            if (line.length === 0) {
+                currentKey = undefined;
+                continue;
+            }
+            const delimiterIndex = line.indexOf(":");
+            if (delimiterIndex < 0) {
+                currentKey = undefined;
+                continue;
+            }
+            const key = line.slice(0, delimiterIndex).trim();
+            const value = line.slice(delimiterIndex + 1).trim();
+            properties.set(key, value);
+            currentKey = key;
+        }
+        const mainDalfPath = properties.get("Main-Dalf");
+        if (mainDalfPath === undefined || mainDalfPath.length === 0) {
+            throw new daml_lf_archive_exception_js_1.DamlLfArchiveException("dar manifest does not declare Main-Dalf");
+        }
+        return new dar_manifest_js_1.DarManifest({
+            mainDalfPath,
+            manifestVersion: properties.get("Manifest-Version"),
+        });
+    }
+}
+exports.DarArchiveLoader = DarArchiveLoader;

package/dist/cjs/daml-lf/container/dar-archive.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DarArchive = void 0;
+class DarArchive {
+    entries;
+    manifest;
+    mainPackageEntry;
+    packageEntries;
+    sourceFiles;
+    constructor(init) {
+        this.entries = init.entries;
+        this.manifest = init.manifest;
+        this.mainPackageEntry = init.mainPackageEntry;
+        this.packageEntries = init.packageEntries;
+        this.sourceFiles = init.sourceFiles;
+    }
+}
+exports.DarArchive = DarArchive;

package/dist/cjs/daml-lf/container/dar-manifest.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DarManifest = void 0;
+class DarManifest {
+    mainDalfPath;
+    manifestVersion;
+    constructor(init) {
+        this.mainDalfPath = init.mainDalfPath;
+        this.manifestVersion = init.manifestVersion;
+    }
+}
+exports.DarManifest = DarManifest;

package/dist/cjs/daml-lf/container/dar-package-entry.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DarPackageEntry = void 0;
+class DarPackageEntry {
+    path;
+    bytes;
+    constructor(init) {
+        this.path = init.path;
+        this.bytes = init.bytes;
+    }
+}
+exports.DarPackageEntry = DarPackageEntry;

package/dist/cjs/daml-lf/container/dar-source-bundle-loader.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DarSourceBundleLoader = void 0;
+const fflate_1 = require("fflate");
+const daml_lf_archive_exception_js_1 = require("../errors/daml-lf-archive.exception.js");
+const dar_archive_loader_js_1 = require("./dar-archive-loader.js");
+const dar_source_bundle_js_1 = require("./dar-source-bundle.js");
+class DarSourceBundleLoader {
+    archiveLoader = new dar_archive_loader_js_1.DarArchiveLoader();
+    async loadSourceBundleOrThrowAsync(archiveBytes) {
+        const archive = await this.archiveLoader.loadDarOrThrowAsync(archiveBytes);
+        const metadataEntry = archive.entries.find((entry) => entry.path === "debug/source-map.json");
+        if (metadataEntry === undefined) {
+            throw new daml_lf_archive_exception_js_1.DamlLfArchiveException("dar archive does not contain debug/source-map.json");
+        }
+        const metadata = JSON.parse((0, fflate_1.strFromU8)(metadataEntry.bytes));
+        if (!Array.isArray(metadata.executables)) {
+            throw new daml_lf_archive_exception_js_1.DamlLfArchiveException("dar source-map metadata must define an executables array");
+        }
+        return new dar_source_bundle_js_1.DarSourceBundle({
+            sourceFiles: archive.sourceFiles,
+            metadata: {
+                packageId: typeof metadata.packageId === "string"
+                    ? metadata.packageId
+                    : undefined,
+                importedPackages: Array.isArray(metadata.importedPackages)
+                    ? metadata.importedPackages.filter((entry) => typeof entry === "string")
+                    : [],
+                executables: metadata.executables,
+                expressionLocations: Array.isArray(metadata.expressionLocations)
+                    ? metadata.expressionLocations
+                    : [],
+            },
+        });
+    }
+}
+exports.DarSourceBundleLoader = DarSourceBundleLoader;

package/dist/cjs/daml-lf/container/dar-source-bundle.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DarSourceBundle = void 0;
+class DarSourceBundle {
+    sourceFiles;
+    metadata;
+    constructor(init) {
+        this.sourceFiles = init.sourceFiles;
+        this.metadata = {
+            ...init.metadata,
+            expressionLocations: init.metadata.expressionLocations ?? [],
+        };
+    }
+}
+exports.DarSourceBundle = DarSourceBundle;

package/dist/cjs/daml-lf/container/dar-source-file-entry.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DarSourceFileEntry = void 0;
+class DarSourceFileEntry {
+    path;
+    content;
+    constructor(init) {
+        this.path = init.path;
+        this.content = init.content;
+    }
+}
+exports.DarSourceFileEntry = DarSourceFileEntry;