@distrohelena/canton-typescript-sdk 0.1.44 → 0.1.46

package/dist/cjs/query/grpc/grpc-query-client.js

@@ -95,21 +95,30 @@ class DefaultGrpcQueryDataProvider {
             const history = await this.snapshots.readHistoryAsync(endInclusive);
             const transactions = history.updates.flatMap((response) => response.update.oneofKind === "transaction" ? [response.update.transaction] : []);
             const fragment = (0, grpc_relation_mapper_js_1.mapGrpcQueryRelationFragment)(transactions);
-            const useCreationsOnlyMetadata = requiresPackageMetadata(closure)
-                && query.relation !== "packages" && query.relation !== "contractTypes" && query.relation !== "exerciseTypes"
-                && derivableFromCreationsOnly(closure);
+            // Catalog queries rooted at packages/contractTypes/exerciseTypes need every known package's
+            // full type inventory, which only the decoded archives provide.
+            const catalogRelation = query.relation === "packages" || query.relation === "contractTypes" || query.relation === "exerciseTypes";
+            const closureNeedsExercises = closure.has("exercises") || closure.has("exerciseTypes");
+            // Non-catalog metadata can usually come straight from the fetched events: creations always name
+            // their own package, and direct exercises name their choice owner's. packageMetadataFromEvents
+            // returns undefined when the window holds an interface-exercised choice (owner package name is
+            // not on the event), and "packages" rows (version) have no event equivalent at all — both fall
+            // back to the archive decode.
+            const derivedMetadata = requiresPackageMetadata(closure) && !catalogRelation && !closure.has("packages")
+                ? closureNeedsExercises
+                    ? (0, grpc_relation_mapper_js_1.packageMetadataFromEvents)(fragment)
+                    : (0, grpc_relation_mapper_js_1.contractTypeMetadataFromCreations)(fragment.creationIdentities)
+                : undefined;
             const packageMetadata = !requiresPackageMetadata(closure)
                 ? []
-                : query.relation === "packages" || query.relation === "contractTypes" || query.relation === "exerciseTypes"
+                : catalogRelation
                     ? await this.packages.readAllAsync()
-                    : useCreationsOnlyMetadata
-                        ? (0, grpc_relation_mapper_js_1.contractTypeMetadataFromCreations)(fragment.creationIdentities)
-                        : await this.packages.readPackagesAsync((0, grpc_relation_mapper_js_1.referencedGrpcPackageIds)(fragment));
-            // The closure guarantees this query never reads "exercises" here, but the replayed window can still
-            // contain unrelated exercises (createGrpcQueryDataset always resolves package metadata for every
-            // exercise in the fragment). contractTypeMetadataFromCreations only knows about templates, so drop
-            // the exercises this query doesn't need instead of paying for their canonical keys.
-            const datasetFragment = useCreationsOnlyMetadata ? { ...fragment, exercises: [] } : fragment;
+                    : derivedMetadata ?? await this.packages.readPackagesAsync((0, grpc_relation_mapper_js_1.referencedGrpcPackageIds)(fragment));
+            // When the closure never reads exercises, the replayed window's unrelated exercises are dropped:
+            // createGrpcQueryDataset resolves canonical keys for every exercise present, and creations-only
+            // metadata knows nothing about choices. When the closure does read exercises, the event-derived
+            // metadata covers them and they stay.
+            const datasetFragment = derivedMetadata !== undefined && !closureNeedsExercises ? { ...fragment, exercises: [] } : fragment;
             return packageMetadata.length === 0
                 ? fragmentDataset(fragment, endInclusive, this.options.endpointScope ?? "ledger")
                 : (0, grpc_relation_mapper_js_1.createGrpcQueryDataset)(datasetFragment, packageMetadata, endInclusive, this.options.endpointScope ?? "ledger");
@@ -292,24 +301,6 @@ function isValidTemplateRef(ref) {
         return false;
     }
 }
-/**
- * True when contractType metadata can be derived from the fetched creation events alone (see
- * contractTypeMetadataFromCreations), instead of decoding LF packages. Every CreatedEvent already carries its
- * own packageName, so this always holds whenever the query's closure needs only "contractTypes" (plus
- * "contracts"/"transactions"/"events", which carry no package linkage of their own). It does NOT extend to
- * "exercises"/"exerciseTypes": ExercisedEvent.packageName documents "the package name of the contract" — i.e.
- * the template side — so it is not a reliable source for the choice owner's package name when a choice was
- * exercised via an interface. "packages" is excluded because its own rows (e.g. version) have no event
- * equivalent at all.
- *
- * The caller is responsible for dropping any exercises the fetched fragment happens to contain before handing
- * it to createGrpcQueryDataset: a full-history fragment reflects the *entire* replayed window, not just what
- * this query's closure touches, and createGrpcQueryDataset unconditionally resolves package metadata for
- * every exercise present — this function only knows about templates, not choices.
- */
-function derivableFromCreationsOnly(closure) {
-    return closure.has("contractTypes") && !closure.has("exercises") && !closure.has("exerciseTypes") && !closure.has("packages");
-}
 function predicateRequiresHistory(relation, predicate) {
     if (predicate === undefined || predicate.kind === "scalar") {
         return false;

package/dist/cjs/query/grpc/grpc-relation-mapper.js

@@ -4,6 +4,7 @@ exports.mapGrpcQueryRelationFragment = mapGrpcQueryRelationFragment;
 exports.createGrpcQueryDataset = createGrpcQueryDataset;
 exports.referencedGrpcPackageIds = referencedGrpcPackageIds;
 exports.contractTypeMetadataFromCreations = contractTypeMetadataFromCreations;
+exports.packageMetadataFromEvents = packageMetadataFromEvents;
 const validation_error_js_1 = require("../../core/errors/validation-error.js");
 const query_dataset_js_1 = require("../canonical/query-dataset.js");
 const public_identity_js_1 = require("../canonical/public-identity.js");
@@ -248,40 +249,92 @@ function referencedGrpcPackageIds(fragment) {
  * Derives contractType metadata straight from already-fetched created-contract events instead of the
  * Package Service. Only valid where the caller has confirmed the query's relation closure is a subset of
  * {contracts, contractTypes} — every contract's own creation event already carries packageName directly,
- * so no archive decode is needed. "version" is a placeholder: this path is unreachable from any query that
- * can see the "packages" relation, so it is never observed.
+ * so no archive decode is needed. "version" is a per-package placeholder: this path is unreachable from
+ * any query that can see the "packages" relation, so it is never observed.
  */
 function contractTypeMetadataFromCreations(creationIdentities) {
     const packages = new Map();
-    for (const creation of creationIdentities) {
-        const packageId = creation.representativePackageId ?? creation.creationPackageId;
-        const { moduleName, entityName } = creation.templateId;
-        let pkg = packages.get(packageId);
-        if (pkg === undefined) {
-            pkg = { name: creation.packageName, templates: new Map() };
-            packages.set(packageId, pkg);
-        }
-        else if (pkg.name !== creation.packageName) {
-            throw new validation_error_js_1.ValidationError(`gRPC query package ${packageId} reports conflicting package names`);
-        }
-        const identity = `${moduleName}${entityName}`;
-        if (!pkg.templates.has(identity)) {
-            const templateFqn = `${pkg.name}:${moduleName}:${entityName}`;
-            pkg.templates.set(identity, Object.freeze({
-                moduleName,
-                entityName,
-                payloadType: "template",
-                aliases: Object.freeze([templateFqn, `${moduleName}:${entityName}`, entityName]),
-                templateFqn,
-                choices: Object.freeze([]),
-            }));
+    addDerivedCreationEntries(packages, creationIdentities);
+    return finalizeDerivedPackages(packages);
+}
+/**
+ * Extends the creations-only derivation to exercises: for a direct exercise the choice owner IS the
+ * exercised template, so the event's own packageName names the owner's package and choice/consuming come
+ * straight off the event. Returns undefined when the window contains an interface-exercised choice — its
+ * owner is the interface, whose package name the event does not carry, so only the decoded archive can
+ * produce its canonical choiceFqn. Unobserved choices are simply absent, which is complete for query plans
+ * that reach exerciseTypes only through observed exercises (never for exerciseTypes catalog queries).
+ */
+function packageMetadataFromEvents(fragment) {
+    if (fragment.typeIdentities.some((identity) => identity.choice !== undefined && identity.packageName === undefined)) {
+        return undefined;
+    }
+    const packages = new Map();
+    addDerivedCreationEntries(packages, fragment.creationIdentities);
+    for (const identity of fragment.typeIdentities) {
+        if (identity.packageName === undefined) {
+            throw new validation_error_js_1.ValidationError("gRPC query contract type identity is missing its package name");
+        }
+        const template = derivedTemplateFor(derivedPackageFor(packages, identity.packageId, identity.packageName), identity.templateId.moduleName, identity.templateId.entityName);
+        if (identity.choice !== undefined) {
+            const consuming = template.choices.get(identity.choice);
+            if (consuming !== undefined && consuming !== identity.consuming) {
+                throw new validation_error_js_1.ValidationError(`gRPC query choice ${identity.choice} reports conflicting consuming flags`);
+            }
+            template.choices.set(identity.choice, identity.consuming === true);
         }
     }
+    return finalizeDerivedPackages(packages);
+}
+function addDerivedCreationEntries(packages, creationIdentities) {
+    for (const creation of creationIdentities) {
+        derivedTemplateFor(derivedPackageFor(packages, creation.representativePackageId ?? creation.creationPackageId, creation.packageName), creation.templateId.moduleName, creation.templateId.entityName);
+    }
+}
+function derivedPackageFor(packages, packageId, packageName) {
+    const existing = packages.get(packageId);
+    if (existing === undefined) {
+        const created = { name: packageName, templates: new Map() };
+        packages.set(packageId, created);
+        return created;
+    }
+    else if (existing.name !== packageName) {
+        throw new validation_error_js_1.ValidationError(`gRPC query package ${packageId} reports conflicting package names`);
+    }
+    return existing;
+}
+function derivedTemplateFor(pkg, moduleName, entityName) {
+    const identity = `${moduleName} ${entityName}`;
+    let template = pkg.templates.get(identity);
+    if (template === undefined) {
+        template = { moduleName, entityName, choices: new Map() };
+        pkg.templates.set(identity, template);
+    }
+    return template;
+}
+function finalizeDerivedPackages(packages) {
     return Object.freeze([...packages.entries()].map(([id, pkg]) => Object.freeze({
         id,
         name: pkg.name,
-        version: "unresolved",
-        templates: Object.freeze([...pkg.templates.values()]),
+        // Unique per package: two versions of the same package name can both appear in one window, and
+        // duplicate name+version pairs are rejected during dataset normalization.
+        version: `unresolved-${id}`,
+        templates: Object.freeze([...pkg.templates.values()].map((template) => {
+            const templateFqn = `${pkg.name}:${template.moduleName}:${template.entityName}`;
+            return Object.freeze({
+                moduleName: template.moduleName,
+                entityName: template.entityName,
+                payloadType: "template",
+                aliases: Object.freeze([templateFqn, `${template.moduleName}:${template.entityName}`, template.entityName]),
+                templateFqn,
+                choices: Object.freeze([...template.choices.entries()].map(([choice, consuming]) => Object.freeze({
+                    choice,
+                    consuming,
+                    aliases: Object.freeze([`${templateFqn}:${choice}`, `${template.moduleName}:${template.entityName}:${choice}`, `${template.entityName}:${choice}`, choice]),
+                    choiceFqn: `${templateFqn}:${choice}`,
+                })).sort((left, right) => left.choice.localeCompare(right.choice))),
+            });
+        })),
     })));
 }
 function compareTemplateMetadata(left, right) {
@@ -304,7 +357,6 @@ function normalizeGrpcPackageMetadataUnsafe(packages) {
     }
     const packageValues = Array.from(packages);
     const packageIds = new Set();
-    const packageNameVersions = new Set();
     const normalized = [];
     for (const pkg of packageValues) {
         if (pkg === null || typeof pkg !== "object") {
@@ -319,11 +371,10 @@ function normalizeGrpcPackageMetadataUnsafe(packages) {
             throw new validation_error_js_1.ValidationError(`gRPC query has duplicate package metadata ${packageId}`);
         }
         packageIds.add(packageId);
-        const nameVersion = `${packageName}\u0000${packageVersion}`;
-        if (packageNameVersions.has(nameVersion)) {
-            throw new validation_error_js_1.ValidationError(`gRPC query has duplicate package metadata ${packageName}@${packageVersion}`);
-        }
-        packageNameVersions.add(nameVersion);
+        // Same name+version under two different ids is NOT rejected: package ids are content-addressed, so a
+        // recompiled or re-uploaded DAR legitimately reappears with a new id and an unchanged manifest. The
+        // name-derived canonical rows go through deduplicateCanonicalRows, which throws on any genuine
+        // metadata conflict for one canonical key — the only conflict that would actually matter.
         const templatesValue = value.templates;
         if (!Array.isArray(templatesValue)) {
             throw new validation_error_js_1.ValidationError(`gRPC query package ${packageId} templates are invalid`);
@@ -569,12 +620,19 @@ function identitiesFor(event) {
 }
 function typeIdentityRows(event, registry) {
     const template = requiredTemplate(event.templateId, "event template");
-    const contract = { pk: registry.get(contractIdentity(template)), templateId: copyTemplate(template), packageId: template.packageId };
+    const contract = { pk: registry.get(contractIdentity(template)), templateId: copyTemplate(template), packageId: template.packageId, packageName: event.packageName };
     if (!isExercised(event)) {
         return [contract];
     }
     const owner = exerciseOwner(event);
-    return [contract, { pk: registry.get(exerciseIdentity(owner, event.choice, event.consuming)), templateId: copyTemplate(owner), packageId: owner.packageId, choice: event.choice, consuming: event.consuming }];
+    return [contract, {
+            pk: registry.get(exerciseIdentity(owner, event.choice, event.consuming)),
+            templateId: copyTemplate(owner),
+            packageId: owner.packageId,
+            ...(event.interfaceId === undefined ? { packageName: event.packageName } : {}),
+            choice: event.choice,
+            consuming: event.consuming,
+        }];
 }
 function activeContractEntries(responses) {
     const entries = responses.map((response) => {

package/dist/query/grpc/grpc-query-client.js

@@ -5,7 +5,7 @@ import { createQueryDataset } from "../canonical/query-dataset.js";
 import { normalizeAggregate, normalizeCount, normalizeFindMany, normalizeFindUnique, normalizeGroupBy } from "../canonical/query-normalizer.js";
 import { queryRelationEdges, queryRelations } from "../canonical/query-schema.js";
 import { QuerySource } from "../query-source.js";
-import { contractTypeMetadataFromCreations, createGrpcQueryDataset, mapGrpcQueryRelationFragment, referencedGrpcPackageIds } from "./grpc-relation-mapper.js";
+import { contractTypeMetadataFromCreations, createGrpcQueryDataset, mapGrpcQueryRelationFragment, packageMetadataFromEvents, referencedGrpcPackageIds } from "./grpc-relation-mapper.js";
 import { GrpcPackageRelationReader } from "./grpc-package-relation-reader.js";
 import { GrpcQuerySnapshotReader } from "./grpc-query-snapshot-reader.js";
 import { validDottedNameString } from "./grpc-query-value-mapper.js";
@@ -91,21 +91,30 @@ class DefaultGrpcQueryDataProvider {
             const history = await this.snapshots.readHistoryAsync(endInclusive);
             const transactions = history.updates.flatMap((response) => response.update.oneofKind === "transaction" ? [response.update.transaction] : []);
             const fragment = mapGrpcQueryRelationFragment(transactions);
-            const useCreationsOnlyMetadata = requiresPackageMetadata(closure)
-                && query.relation !== "packages" && query.relation !== "contractTypes" && query.relation !== "exerciseTypes"
-                && derivableFromCreationsOnly(closure);
+            // Catalog queries rooted at packages/contractTypes/exerciseTypes need every known package's
+            // full type inventory, which only the decoded archives provide.
+            const catalogRelation = query.relation === "packages" || query.relation === "contractTypes" || query.relation === "exerciseTypes";
+            const closureNeedsExercises = closure.has("exercises") || closure.has("exerciseTypes");
+            // Non-catalog metadata can usually come straight from the fetched events: creations always name
+            // their own package, and direct exercises name their choice owner's. packageMetadataFromEvents
+            // returns undefined when the window holds an interface-exercised choice (owner package name is
+            // not on the event), and "packages" rows (version) have no event equivalent at all — both fall
+            // back to the archive decode.
+            const derivedMetadata = requiresPackageMetadata(closure) && !catalogRelation && !closure.has("packages")
+                ? closureNeedsExercises
+                    ? packageMetadataFromEvents(fragment)
+                    : contractTypeMetadataFromCreations(fragment.creationIdentities)
+                : undefined;
             const packageMetadata = !requiresPackageMetadata(closure)
                 ? []
-                : query.relation === "packages" || query.relation === "contractTypes" || query.relation === "exerciseTypes"
+                : catalogRelation
                     ? await this.packages.readAllAsync()
-                    : useCreationsOnlyMetadata
-                        ? contractTypeMetadataFromCreations(fragment.creationIdentities)
-                        : await this.packages.readPackagesAsync(referencedGrpcPackageIds(fragment));
-            // The closure guarantees this query never reads "exercises" here, but the replayed window can still
-            // contain unrelated exercises (createGrpcQueryDataset always resolves package metadata for every
-            // exercise in the fragment). contractTypeMetadataFromCreations only knows about templates, so drop
-            // the exercises this query doesn't need instead of paying for their canonical keys.
-            const datasetFragment = useCreationsOnlyMetadata ? { ...fragment, exercises: [] } : fragment;
+                    : derivedMetadata ?? await this.packages.readPackagesAsync(referencedGrpcPackageIds(fragment));
+            // When the closure never reads exercises, the replayed window's unrelated exercises are dropped:
+            // createGrpcQueryDataset resolves canonical keys for every exercise present, and creations-only
+            // metadata knows nothing about choices. When the closure does read exercises, the event-derived
+            // metadata covers them and they stay.
+            const datasetFragment = derivedMetadata !== undefined && !closureNeedsExercises ? { ...fragment, exercises: [] } : fragment;
             return packageMetadata.length === 0
                 ? fragmentDataset(fragment, endInclusive, this.options.endpointScope ?? "ledger")
                 : createGrpcQueryDataset(datasetFragment, packageMetadata, endInclusive, this.options.endpointScope ?? "ledger");
@@ -288,24 +297,6 @@ function isValidTemplateRef(ref) {
         return false;
     }
 }
-/**
- * True when contractType metadata can be derived from the fetched creation events alone (see
- * contractTypeMetadataFromCreations), instead of decoding LF packages. Every CreatedEvent already carries its
- * own packageName, so this always holds whenever the query's closure needs only "contractTypes" (plus
- * "contracts"/"transactions"/"events", which carry no package linkage of their own). It does NOT extend to
- * "exercises"/"exerciseTypes": ExercisedEvent.packageName documents "the package name of the contract" — i.e.
- * the template side — so it is not a reliable source for the choice owner's package name when a choice was
- * exercised via an interface. "packages" is excluded because its own rows (e.g. version) have no event
- * equivalent at all.
- *
- * The caller is responsible for dropping any exercises the fetched fragment happens to contain before handing
- * it to createGrpcQueryDataset: a full-history fragment reflects the *entire* replayed window, not just what
- * this query's closure touches, and createGrpcQueryDataset unconditionally resolves package metadata for
- * every exercise present — this function only knows about templates, not choices.
- */
-function derivableFromCreationsOnly(closure) {
-    return closure.has("contractTypes") && !closure.has("exercises") && !closure.has("exerciseTypes") && !closure.has("packages");
-}
 function predicateRequiresHistory(relation, predicate) {
     if (predicate === undefined || predicate.kind === "scalar") {
         return false;

package/dist/query/grpc/grpc-relation-mapper.d.ts

@@ -11,6 +11,13 @@ export interface GrpcQueryTypeIdentity {
         entityName: string;
     }>;
     readonly packageId: string;
+    /**
+     * The owning package's name when the event states it reliably: always for contract types
+     * (CreatedEvent/ExercisedEvent packageName is the contract's package), and for choice types only on
+     * direct exercises — an interface-exercised choice is owned by the interface, whose package name the
+     * event does not carry.
+     */
+    readonly packageName?: string;
     readonly choice?: string;
     readonly consuming?: boolean;
 }
@@ -70,7 +77,16 @@ export declare function referencedGrpcPackageIds(fragment: GrpcQueryRelationFrag
  * Derives contractType metadata straight from already-fetched created-contract events instead of the
  * Package Service. Only valid where the caller has confirmed the query's relation closure is a subset of
  * {contracts, contractTypes} — every contract's own creation event already carries packageName directly,
- * so no archive decode is needed. "version" is a placeholder: this path is unreachable from any query that
- * can see the "packages" relation, so it is never observed.
+ * so no archive decode is needed. "version" is a per-package placeholder: this path is unreachable from
+ * any query that can see the "packages" relation, so it is never observed.
  */
 export declare function contractTypeMetadataFromCreations(creationIdentities: readonly GrpcQueryCreationIdentity[]): readonly GrpcPackageMetadata[];
+/**
+ * Extends the creations-only derivation to exercises: for a direct exercise the choice owner IS the
+ * exercised template, so the event's own packageName names the owner's package and choice/consuming come
+ * straight off the event. Returns undefined when the window contains an interface-exercised choice — its
+ * owner is the interface, whose package name the event does not carry, so only the decoded archive can
+ * produce its canonical choiceFqn. Unobserved choices are simply absent, which is complete for query plans
+ * that reach exerciseTypes only through observed exercises (never for exerciseTypes catalog queries).
+ */
+export declare function packageMetadataFromEvents(fragment: Pick<GrpcQueryRelationFragment, "creationIdentities" | "typeIdentities">): readonly GrpcPackageMetadata[] | undefined;

package/dist/query/grpc/grpc-relation-mapper.js

@@ -242,40 +242,92 @@ export function referencedGrpcPackageIds(fragment) {
  * Derives contractType metadata straight from already-fetched created-contract events instead of the
  * Package Service. Only valid where the caller has confirmed the query's relation closure is a subset of
  * {contracts, contractTypes} — every contract's own creation event already carries packageName directly,
- * so no archive decode is needed. "version" is a placeholder: this path is unreachable from any query that
- * can see the "packages" relation, so it is never observed.
+ * so no archive decode is needed. "version" is a per-package placeholder: this path is unreachable from
+ * any query that can see the "packages" relation, so it is never observed.
  */
 export function contractTypeMetadataFromCreations(creationIdentities) {
     const packages = new Map();
-    for (const creation of creationIdentities) {
-        const packageId = creation.representativePackageId ?? creation.creationPackageId;
-        const { moduleName, entityName } = creation.templateId;
-        let pkg = packages.get(packageId);
-        if (pkg === undefined) {
-            pkg = { name: creation.packageName, templates: new Map() };
-            packages.set(packageId, pkg);
-        }
-        else if (pkg.name !== creation.packageName) {
-            throw new ValidationError(`gRPC query package ${packageId} reports conflicting package names`);
-        }
-        const identity = `${moduleName}${entityName}`;
-        if (!pkg.templates.has(identity)) {
-            const templateFqn = `${pkg.name}:${moduleName}:${entityName}`;
-            pkg.templates.set(identity, Object.freeze({
-                moduleName,
-                entityName,
-                payloadType: "template",
-                aliases: Object.freeze([templateFqn, `${moduleName}:${entityName}`, entityName]),
-                templateFqn,
-                choices: Object.freeze([]),
-            }));
+    addDerivedCreationEntries(packages, creationIdentities);
+    return finalizeDerivedPackages(packages);
+}
+/**
+ * Extends the creations-only derivation to exercises: for a direct exercise the choice owner IS the
+ * exercised template, so the event's own packageName names the owner's package and choice/consuming come
+ * straight off the event. Returns undefined when the window contains an interface-exercised choice — its
+ * owner is the interface, whose package name the event does not carry, so only the decoded archive can
+ * produce its canonical choiceFqn. Unobserved choices are simply absent, which is complete for query plans
+ * that reach exerciseTypes only through observed exercises (never for exerciseTypes catalog queries).
+ */
+export function packageMetadataFromEvents(fragment) {
+    if (fragment.typeIdentities.some((identity) => identity.choice !== undefined && identity.packageName === undefined)) {
+        return undefined;
+    }
+    const packages = new Map();
+    addDerivedCreationEntries(packages, fragment.creationIdentities);
+    for (const identity of fragment.typeIdentities) {
+        if (identity.packageName === undefined) {
+            throw new ValidationError("gRPC query contract type identity is missing its package name");
+        }
+        const template = derivedTemplateFor(derivedPackageFor(packages, identity.packageId, identity.packageName), identity.templateId.moduleName, identity.templateId.entityName);
+        if (identity.choice !== undefined) {
+            const consuming = template.choices.get(identity.choice);
+            if (consuming !== undefined && consuming !== identity.consuming) {
+                throw new ValidationError(`gRPC query choice ${identity.choice} reports conflicting consuming flags`);
+            }
+            template.choices.set(identity.choice, identity.consuming === true);
         }
     }
+    return finalizeDerivedPackages(packages);
+}
+function addDerivedCreationEntries(packages, creationIdentities) {
+    for (const creation of creationIdentities) {
+        derivedTemplateFor(derivedPackageFor(packages, creation.representativePackageId ?? creation.creationPackageId, creation.packageName), creation.templateId.moduleName, creation.templateId.entityName);
+    }
+}
+function derivedPackageFor(packages, packageId, packageName) {
+    const existing = packages.get(packageId);
+    if (existing === undefined) {
+        const created = { name: packageName, templates: new Map() };
+        packages.set(packageId, created);
+        return created;
+    }
+    else if (existing.name !== packageName) {
+        throw new ValidationError(`gRPC query package ${packageId} reports conflicting package names`);
+    }
+    return existing;
+}
+function derivedTemplateFor(pkg, moduleName, entityName) {
+    const identity = `${moduleName} ${entityName}`;
+    let template = pkg.templates.get(identity);
+    if (template === undefined) {
+        template = { moduleName, entityName, choices: new Map() };
+        pkg.templates.set(identity, template);
+    }
+    return template;
+}
+function finalizeDerivedPackages(packages) {
     return Object.freeze([...packages.entries()].map(([id, pkg]) => Object.freeze({
         id,
         name: pkg.name,
-        version: "unresolved",
-        templates: Object.freeze([...pkg.templates.values()]),
+        // Unique per package: two versions of the same package name can both appear in one window, and
+        // duplicate name+version pairs are rejected during dataset normalization.
+        version: `unresolved-${id}`,
+        templates: Object.freeze([...pkg.templates.values()].map((template) => {
+            const templateFqn = `${pkg.name}:${template.moduleName}:${template.entityName}`;
+            return Object.freeze({
+                moduleName: template.moduleName,
+                entityName: template.entityName,
+                payloadType: "template",
+                aliases: Object.freeze([templateFqn, `${template.moduleName}:${template.entityName}`, template.entityName]),
+                templateFqn,
+                choices: Object.freeze([...template.choices.entries()].map(([choice, consuming]) => Object.freeze({
+                    choice,
+                    consuming,
+                    aliases: Object.freeze([`${templateFqn}:${choice}`, `${template.moduleName}:${template.entityName}:${choice}`, `${template.entityName}:${choice}`, choice]),
+                    choiceFqn: `${templateFqn}:${choice}`,
+                })).sort((left, right) => left.choice.localeCompare(right.choice))),
+            });
+        })),
     })));
 }
 function compareTemplateMetadata(left, right) {
@@ -298,7 +350,6 @@ function normalizeGrpcPackageMetadataUnsafe(packages) {
     }
     const packageValues = Array.from(packages);
     const packageIds = new Set();
-    const packageNameVersions = new Set();
     const normalized = [];
     for (const pkg of packageValues) {
         if (pkg === null || typeof pkg !== "object") {
@@ -313,11 +364,10 @@ function normalizeGrpcPackageMetadataUnsafe(packages) {
             throw new ValidationError(`gRPC query has duplicate package metadata ${packageId}`);
         }
         packageIds.add(packageId);
-        const nameVersion = `${packageName}\u0000${packageVersion}`;
-        if (packageNameVersions.has(nameVersion)) {
-            throw new ValidationError(`gRPC query has duplicate package metadata ${packageName}@${packageVersion}`);
-        }
-        packageNameVersions.add(nameVersion);
+        // Same name+version under two different ids is NOT rejected: package ids are content-addressed, so a
+        // recompiled or re-uploaded DAR legitimately reappears with a new id and an unchanged manifest. The
+        // name-derived canonical rows go through deduplicateCanonicalRows, which throws on any genuine
+        // metadata conflict for one canonical key — the only conflict that would actually matter.
         const templatesValue = value.templates;
         if (!Array.isArray(templatesValue)) {
             throw new ValidationError(`gRPC query package ${packageId} templates are invalid`);
@@ -563,12 +613,19 @@ function identitiesFor(event) {
 }
 function typeIdentityRows(event, registry) {
     const template = requiredTemplate(event.templateId, "event template");
-    const contract = { pk: registry.get(contractIdentity(template)), templateId: copyTemplate(template), packageId: template.packageId };
+    const contract = { pk: registry.get(contractIdentity(template)), templateId: copyTemplate(template), packageId: template.packageId, packageName: event.packageName };
     if (!isExercised(event)) {
         return [contract];
     }
     const owner = exerciseOwner(event);
-    return [contract, { pk: registry.get(exerciseIdentity(owner, event.choice, event.consuming)), templateId: copyTemplate(owner), packageId: owner.packageId, choice: event.choice, consuming: event.consuming }];
+    return [contract, {
+            pk: registry.get(exerciseIdentity(owner, event.choice, event.consuming)),
+            templateId: copyTemplate(owner),
+            packageId: owner.packageId,
+            ...(event.interfaceId === undefined ? { packageName: event.packageName } : {}),
+            choice: event.choice,
+            consuming: event.consuming,
+        }];
 }
 function activeContractEntries(responses) {
     const entries = responses.map((response) => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@distrohelena/canton-typescript-sdk",
-    "version": "0.1.44",
+    "version": "0.1.46",
     "license": "Apache-2.0",
     "type": "module",
     "main": "./dist/index.js",