@intentius/chant 0.8.1 → 0.9.0

package/src/graph-detail.ts

@@ -0,0 +1,149 @@
+import type { GraphIR, IRNode, IREdge } from "./graph-ir";
+
+/**
+ * Detail tiers — the diagram "detail dial". Each level is a pure IR → IR
+ * transform over the base graph IR (no re-discovery), so every emitter and the
+ * painter get them for free. See issue #494 / epic #492.
+ *
+ * - 0 STACKS      — one node per lexicon; edges are cross-lexicon dependencies
+ * - 1 COMPOSITES  — composite instances collapsed to a single node each
+ * - 2 DECLARABLES — every resource (the base produced by buildGraphIr)
+ * - 3 ATTRIBUTES  — declarables plus the producer attribute on each edge
+ */
+export type DetailLevel = 0 | 1 | 2 | 3;
+
+export const DETAIL = {
+  STACKS: 0,
+  COMPOSITES: 1,
+  DECLARABLES: 2,
+  ATTRIBUTES: 3,
+} as const;
+
+/** Apply a detail tier to the base (declarable-level) IR. */
+export function applyDetail(ir: GraphIR, level: DetailLevel): GraphIR {
+  switch (level) {
+    case 0:
+      return toStacks(ir);
+    case 1:
+      return toComposites(ir);
+    case 3:
+      return toAttributes(ir);
+    case 2:
+    default:
+      return ir;
+  }
+}
+
+function edgeSortKey(e: IREdge): string {
+  return `${e.from}\0${e.to}\0${e.viaAttr ?? ""}`;
+}
+
+function sortEdges(edges: IREdge[]): IREdge[] {
+  return edges.sort((a, b) => edgeSortKey(a).localeCompare(edgeSortKey(b)));
+}
+
+function byLexiconOf(nodes: IRNode[]): Record<string, string[]> {
+  const out: Record<string, string[]> = {};
+  for (const n of nodes) (out[n.lexicon] ??= []).push(n.id);
+  const sorted: Record<string, string[]> = {};
+  for (const k of Object.keys(out).sort()) sorted[k] = out[k].sort();
+  return sorted;
+}
+
+/** T0 — collapse every resource to its lexicon; edges become cross-lexicon deps. */
+function toStacks(ir: GraphIR): GraphIR {
+  const lexOf = new Map(ir.nodes.map((n) => [n.id, n.lexicon]));
+  const lexicons = [...new Set(ir.nodes.map((n) => n.lexicon))].sort();
+  const nodes: IRNode[] = lexicons.map((l) => ({ id: l, kind: "stack", lexicon: l, attrs: {} }));
+
+  const seen = new Map<string, IREdge>();
+  for (const e of ir.edges) {
+    const from = lexOf.get(e.from);
+    const to = lexOf.get(e.to);
+    if (!from || !to || from === to) continue;
+    const key = `${from}\0${to}`;
+    if (!seen.has(key)) seen.set(key, { from, to, kind: "ref" });
+  }
+  return { nodes, edges: sortEdges([...seen.values()]), groups: {} };
+}
+
+/** T1 — collapse each composite instance to one node; internal edges disappear. */
+function toComposites(ir: GraphIR): GraphIR {
+  const idMap = new Map<string, string>();
+  for (const n of ir.nodes) idMap.set(n.id, n.compositeInstance ?? n.id);
+
+  const instances = new Map<string, IRNode[]>();
+  const plain: IRNode[] = [];
+  for (const n of ir.nodes) {
+    if (n.compositeInstance) {
+      const arr = instances.get(n.compositeInstance) ?? [];
+      arr.push(n);
+      instances.set(n.compositeInstance, arr);
+    } else {
+      plain.push({ ...n });
+    }
+  }
+
+  const nodes: IRNode[] = [...plain];
+  for (const [inst, members] of instances) {
+    const types = new Set(members.map((m) => m.compositeParent).filter(Boolean) as string[]);
+    const lexicons = new Set(members.map((m) => m.lexicon));
+    nodes.push({
+      id: inst,
+      kind: types.size === 1 ? [...types][0] : "Composite",
+      lexicon: lexicons.size === 1 ? [...lexicons][0] : "multi",
+      attrs: { members: members.length },
+    });
+  }
+
+  const seen = new Map<string, IREdge>();
+  for (const e of ir.edges) {
+    const from = idMap.get(e.from) ?? e.from;
+    const to = idMap.get(e.to) ?? e.to;
+    if (from === to) continue; // edge internal to a composite
+    // A property label only makes sense when neither endpoint was collapsed.
+    const collapsed = from !== e.from || to !== e.to;
+    const edge: IREdge = collapsed
+      ? { from, to, kind: "ref" }
+      : { from, to, kind: "ref", viaAttr: e.viaAttr };
+    const key = `${from}\0${to}\0${edge.viaAttr ?? ""}`;
+    if (!seen.has(key)) seen.set(key, edge);
+  }
+
+  nodes.sort((a, b) => a.id.localeCompare(b.id));
+  return { nodes, edges: sortEdges([...seen.values()]), groups: { byLexicon: byLexiconOf(nodes) } };
+}
+
+/** T3 — annotate each edge with the producer attribute it references. */
+function toAttributes(ir: GraphIR): GraphIR {
+  const nodeById = new Map(ir.nodes.map((n) => [n.id, n]));
+  const edges = ir.edges.map((e) => {
+    const node = nodeById.get(e.from);
+    const toAttr = node ? findRefAttr(node.attrs, e.to) : undefined;
+    return toAttr ? { ...e, toAttr } : { ...e };
+  });
+  return { ...ir, edges };
+}
+
+/** Find the attribute in a `{ $ref: "producer.attribute" }` envelope under attrs. */
+function findRefAttr(attrs: Record<string, unknown>, producer: string): string | undefined {
+  let found: string | undefined;
+  const visit = (v: unknown): void => {
+    if (found !== undefined || v === null || typeof v !== "object") return;
+    if (Array.isArray(v)) {
+      for (const item of v) visit(item);
+      return;
+    }
+    const ref = (v as { $ref?: unknown }).$ref;
+    if (typeof ref === "string") {
+      const dot = ref.indexOf(".");
+      if (dot > 0 && ref.slice(0, dot) === producer) {
+        found = ref.slice(dot + 1);
+        return;
+      }
+    }
+    for (const val of Object.values(v as Record<string, unknown>)) visit(val);
+  };
+  visit(attrs);
+  return found;
+}

package/src/graph-ir.test.ts

@@ -0,0 +1,122 @@
+import { describe, test, expect } from "vitest";
+import { buildGraphIr } from "./graph-ir";
+import { DECLARABLE_MARKER, type Declarable } from "./declarable";
+import { AttrRef } from "./attrref";
+import { resolveAttrRefs } from "./discovery/resolve";
+import { setProvenance } from "./provenance";
+
+function decl<T extends object>(base: T): Declarable & T {
+  return { [DECLARABLE_MARKER]: true, ...base } as Declarable & T;
+}
+
+describe("buildGraphIr", () => {
+  test("emits a node per resource with kind, lexicon, and scrubbed attrs", () => {
+    const vpc = decl({ lexicon: "gcp", entityType: "Vpc", props: { autoCreateSubnetworks: false } });
+    const entities = new Map<string, Declarable>([["vpc", vpc]]);
+    resolveAttrRefs(entities);
+
+    const ir = buildGraphIr(entities);
+    expect(ir.nodes).toHaveLength(1);
+    expect(ir.nodes[0]).toMatchObject({ id: "vpc", kind: "Vpc", lexicon: "gcp" });
+    // `props` is flattened into attrs (field reads as the property, not props.x).
+    expect(ir.nodes[0].attrs).toEqual({ autoCreateSubnetworks: false });
+    // Framework fields are scrubbed out of attrs.
+    expect(ir.nodes[0].attrs).not.toHaveProperty("lexicon");
+    expect(ir.nodes[0].attrs).not.toHaveProperty("entityType");
+  });
+
+  test("derives ref edges labelled with the consumer property", () => {
+    const vpc = decl({ lexicon: "gcp", entityType: "Vpc" });
+    const subnet = decl({ lexicon: "gcp", entityType: "Subnet", props: { network: new AttrRef(vpc, "id") } });
+    const entities = new Map<string, Declarable>([
+      ["vpc", vpc],
+      ["subnet", subnet],
+    ]);
+    resolveAttrRefs(entities);
+
+    const ir = buildGraphIr(entities);
+    expect(ir.edges).toEqual([{ from: "subnet", to: "vpc", kind: "ref", viaAttr: "network" }]);
+    // The ref also appears in the consumer's attrs as an auditable envelope.
+    expect(ir.nodes.find((n) => n.id === "subnet")!.attrs).toEqual({
+      network: { $ref: "vpc.id" },
+    });
+  });
+
+  test("excludes property-kind declarables and keeps resources", () => {
+    const resource = decl({ lexicon: "k8s", entityType: "Deployment" });
+    const prop = decl({ lexicon: "k8s", entityType: "Probe", kind: "property" as const });
+    const entities = new Map<string, Declarable>([
+      ["dep", resource],
+      ["probe", prop],
+    ]);
+    resolveAttrRefs(entities);
+
+    const ir = buildGraphIr(entities);
+    expect(ir.nodes.map((n) => n.id)).toEqual(["dep"]);
+  });
+
+  test("populates compositeParent and byComposite from provenance", () => {
+    const sts = decl({ lexicon: "k8s", entityType: "StatefulSet" });
+    const svc = decl({ lexicon: "k8s", entityType: "Service" });
+    setProvenance(sts, { composite: "CockroachDbCluster", sourceFile: "/proj/src/db.ts" });
+    setProvenance(svc, { composite: "CockroachDbCluster", sourceFile: "/proj/src/db.ts" });
+    const entities = new Map<string, Declarable>([
+      ["dbSts", sts],
+      ["dbSvc", svc],
+    ]);
+    resolveAttrRefs(entities);
+
+    const ir = buildGraphIr(entities, "/proj");
+    expect(ir.nodes.every((n) => n.compositeParent === "CockroachDbCluster")).toBe(true);
+    expect(ir.groups.byComposite).toEqual({ CockroachDbCluster: ["dbSts", "dbSvc"] });
+    // Source file is relativized to the project root.
+    expect(ir.nodes[0].sourceLoc).toEqual({ file: "src/db.ts" });
+  });
+
+  test("reads non-enumerable props like real lexicon entities", () => {
+    // Real lexicon resources define lexicon/entityType/props as non-enumerable,
+    // so Object.entries(entity) is empty — attrs and edges must come from props.
+    const vpc = decl({ lexicon: "gcp", entityType: "Vpc" });
+    const subnet = { [DECLARABLE_MARKER]: true } as Declarable & { props: unknown };
+    Object.defineProperties(subnet, {
+      lexicon: { value: "gcp", enumerable: false },
+      entityType: { value: "Subnet", enumerable: false },
+      props: { value: { cidr: "10.0.0.0/16", network: new AttrRef(vpc, "id") }, enumerable: false },
+    });
+    const entities = new Map<string, Declarable>([
+      ["vpc", vpc],
+      ["subnet", subnet],
+    ]);
+    resolveAttrRefs(entities);
+
+    const ir = buildGraphIr(entities);
+    const subnetNode = ir.nodes.find((n) => n.id === "subnet")!;
+    expect(subnetNode.attrs).toEqual({ cidr: "10.0.0.0/16", network: { $ref: "vpc.id" } });
+    expect(ir.edges).toEqual([{ from: "subnet", to: "vpc", kind: "ref", viaAttr: "network" }]);
+  });
+
+  test("groups nodes by lexicon and is deterministic", () => {
+    const a = decl({ lexicon: "gcp", entityType: "Vpc" });
+    const b = decl({ lexicon: "k8s", entityType: "Namespace" });
+    const c = decl({ lexicon: "gcp", entityType: "Subnet" });
+    const entities = new Map<string, Declarable>([
+      ["zeta", c],
+      ["alpha", a],
+      ["mid", b],
+    ]);
+    resolveAttrRefs(entities);
+
+    const ir = buildGraphIr(entities);
+    expect(ir.nodes.map((n) => n.id)).toEqual(["alpha", "mid", "zeta"]); // sorted
+    expect(ir.groups.byLexicon).toEqual({ gcp: ["alpha", "zeta"], k8s: ["mid"] });
+
+    // Same input (different insertion order) yields identical IR.
+    const reordered = new Map<string, Declarable>([
+      ["alpha", a],
+      ["mid", b],
+      ["zeta", c],
+    ]);
+    resolveAttrRefs(reordered);
+    expect(JSON.stringify(buildGraphIr(reordered))).toEqual(JSON.stringify(ir));
+  });
+});

package/src/graph-ir.ts

@@ -0,0 +1,285 @@
+import { relative, isAbsolute } from "node:path";
+import { AttrRef } from "./attrref";
+import { type Declarable, isDeclarable } from "./declarable";
+import { isLexiconOutput } from "./lexicon-output";
+import { getProvenance } from "./provenance";
+import { INTRINSIC_MARKER } from "./intrinsic";
+
+/**
+ * Graph IR — the engine-neutral, lint-gated representation of a project's
+ * resolved infrastructure graph. Painters (mermaid, graphviz, custom SVG) and
+ * the agentic diagrammer consume this; it is a pure function of lint-clean
+ * source. Every node traces to the file that declared it; every edge is a real
+ * cross-resource reference (AttrRef).
+ *
+ * Emitted by `chant graph --format ir`. See issue #493 / epic #492.
+ */
+
+/** Where in the source a node came from. Entity-level (file), not a line map. */
+export interface SourceLoc {
+  /** Path of the declaring file, relative to the project root when possible. */
+  file: string;
+  /**
+   * Line number, when available. Provenance is entity-level today, so this is
+   * usually absent — reserved for a future source map.
+   */
+  line?: number;
+}
+
+/** A reference in an attribute projection: `<producer>.<attribute>`. */
+export interface AttrRefEnvelope {
+  $ref: string;
+}
+
+/** One resource in the graph. */
+export interface IRNode {
+  /** Logical name (the export name, or composite-expanded name). */
+  id: string;
+  /** Resource type, e.g. "GkeCluster". */
+  kind: string;
+  /** Lexicon the resource belongs to, e.g. "gcp". */
+  lexicon: string;
+  /**
+   * Name of the composite *type* that expanded this node, when it came from one
+   * (e.g. "CockroachDbCluster").
+   */
+  compositeParent?: string;
+  /**
+   * The composite *instance* (export name) this node belongs to — shared by every
+   * node from the same composite call. Detail tiers collapse on this (#494).
+   */
+  compositeInstance?: string;
+  /** Literal/const/ref-resolved props. References appear as `{ $ref }`. */
+  attrs: Record<string, unknown>;
+  /** Where the node was declared. */
+  sourceLoc?: SourceLoc;
+}
+
+/** A directed dependency: `from` references an attribute of `to`. */
+export interface IREdge {
+  from: string;
+  to: string;
+  /** "ref" for an AttrRef-derived edge. */
+  kind: "ref";
+  /** The consumer-side property the reference flows through, when derivable. */
+  viaAttr?: string;
+  /** The producer-side attribute referenced (e.g. "id"). Added at detail T3. */
+  toAttr?: string;
+}
+
+/** Grouping metadata for cluster/subgraph rendering. Maps group name -> node ids. */
+export interface IRGroups {
+  byLexicon?: Record<string, string[]>;
+  byComposite?: Record<string, string[]>;
+  /** Reserved for stack grouping (#494). */
+  byStack?: Record<string, string[]>;
+}
+
+/** The full graph IR for a project at the default (declarable) detail level. */
+export interface GraphIR {
+  nodes: IRNode[];
+  edges: IREdge[];
+  groups: IRGroups;
+}
+
+/** A node is anything that serializes to a resource — not a property or output. */
+function isNodeEntity(entity: Declarable): boolean {
+  if (isLexiconOutput(entity)) return false;
+  if (entity.kind === "property") return false;
+  return true;
+}
+
+function relFile(file: string | undefined, projectPath?: string): string | undefined {
+  if (!file) return undefined;
+  if (projectPath && isAbsolute(file)) {
+    const rel = relative(projectPath, file);
+    return rel.startsWith("..") ? file : rel;
+  }
+  return file;
+}
+
+/** Resolve the producer (logical name) an AttrRef points at. */
+function refTarget(ref: AttrRef, reverse: Map<object, string>): string | undefined {
+  // Nested refs (under `props`) aren't assigned a logical name by resolveAttrRefs,
+  // which only resolves top-level own props — so fall back to the parent's name.
+  const parent = ref.parent.deref();
+  return ref.getLogicalName() ?? (parent ? reverse.get(parent) : undefined);
+}
+
+/** Project a value into a JSON-safe, scrubbed form. References become `{ $ref }`. */
+function project(value: unknown, seen: Set<unknown>, reverse: Map<object, string>): unknown {
+  if (value === null) return null;
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean") return value;
+  if (t !== "object") return undefined; // functions, symbols, undefined
+
+  if (value instanceof AttrRef) {
+    const to = refTarget(value, reverse);
+    return { $ref: to ? `${to}.${value.attribute}` : value.attribute } satisfies AttrRefEnvelope;
+  }
+  // Other intrinsics (interpolations, pseudo-parameters): mark, don't inline.
+  if ((value as Record<symbol, unknown>)[INTRINSIC_MARKER] === true) {
+    return { $intrinsic: true };
+  }
+
+  if (seen.has(value)) return undefined; // break cycles
+  seen.add(value);
+
+  // Nested declarables (e.g. an inlined property-kind resource) keep their
+  // config in a non-enumerable `props` bag, like top-level nodes — project that.
+  if (isDeclarable(value)) {
+    const out = projectConfig(value, seen, reverse);
+    seen.delete(value);
+    return out;
+  }
+
+  if (Array.isArray(value)) {
+    const out = value.map((v) => project(v, seen, reverse)).filter((v) => v !== undefined);
+    seen.delete(value);
+    return out;
+  }
+
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+    const p = project(v, seen, reverse);
+    if (p !== undefined) out[k] = p;
+  }
+  seen.delete(value);
+  return out;
+}
+
+const SKIP_KEYS = new Set(["lexicon", "entityType", "kind", "attributes", "Ref"]);
+
+/** The config bag of a node, paired with each key. Lexicon entities keep their
+ * declared props in a (usually non-enumerable) `props` object; simpler entities
+ * carry config as enumerable own properties. We surface both, flattening `props`
+ * so a field reads as e.g. `network`, not `props.network`. */
+function configRoots(entity: Declarable): Array<[string, unknown]> {
+  const out: Array<[string, unknown]> = [];
+  for (const [k, v] of Object.entries(entity)) {
+    if (SKIP_KEYS.has(k) || k === "props") continue;
+    out.push([k, v]);
+  }
+  const props = (entity as unknown as { props?: unknown }).props;
+  if (props && typeof props === "object" && !Array.isArray(props)) {
+    for (const [k, v] of Object.entries(props as Record<string, unknown>)) out.push([k, v]);
+  }
+  return out;
+}
+
+/** Project a declarable's config bag (flattened props + enumerable own props). */
+function projectConfig(
+  entity: Declarable,
+  seen: Set<unknown>,
+  reverse: Map<object, string>,
+): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of configRoots(entity)) {
+    const p = project(v, seen, reverse);
+    if (p !== undefined) out[k] = p;
+  }
+  return out;
+}
+
+/** Collect ref edges from one node, labelling each with its consumer property. */
+function collectEdges(
+  entity: Declarable,
+  from: string,
+  nodeIds: Set<string>,
+  reverse: Map<object, string>,
+): IREdge[] {
+  const edges: IREdge[] = [];
+  const seen = new Set<unknown>();
+  const visit = (value: unknown, viaAttr: string): void => {
+    if (value === null || typeof value !== "object") return;
+    if (value instanceof AttrRef) {
+      const to = refTarget(value, reverse);
+      if (to && to !== from && nodeIds.has(to)) {
+        edges.push({ from, to, kind: "ref", viaAttr });
+      }
+      return;
+    }
+    if ((value as Record<symbol, unknown>)[INTRINSIC_MARKER] === true) return;
+    if (seen.has(value)) return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item, viaAttr);
+      return;
+    }
+    for (const v of Object.values(value as Record<string, unknown>)) visit(v, viaAttr);
+  };
+  for (const [k, v] of configRoots(entity)) visit(v, k);
+  return edges;
+}
+
+/** Stable key for deduping and sorting an edge. */
+function edgeKey(e: IREdge): string {
+  return `${e.from}\0${e.to}\0${e.viaAttr ?? ""}`;
+}
+
+/**
+ * Build the graph IR from resolved entities (the output of `discover`). Pure and
+ * deterministic: nodes and edges are sorted, so the same source yields identical
+ * IR. `projectPath` relativizes source-file paths for portable output.
+ */
+export function buildGraphIr(
+  entities: Map<string, Declarable>,
+  projectPath?: string,
+): GraphIR {
+  // Reverse lookup for producers whose AttrRef logical name wasn't resolved.
+  const reverse = new Map<object, string>();
+  for (const [name, entity] of entities) reverse.set(entity, name);
+
+  const nodeIds = new Set<string>();
+  for (const [name, entity] of entities) {
+    if (isNodeEntity(entity)) nodeIds.add(name);
+  }
+
+  const nodes: IRNode[] = [];
+  const byLexicon: Record<string, string[]> = {};
+  const byComposite: Record<string, string[]> = {};
+
+  for (const [name, entity] of entities) {
+    if (!nodeIds.has(name)) continue;
+    const prov = getProvenance(entity);
+    const node: IRNode = {
+      id: name,
+      kind: entity.entityType,
+      lexicon: entity.lexicon,
+      attrs: projectConfig(entity, new Set(), reverse),
+    };
+    if (prov?.composite) node.compositeParent = prov.composite;
+    if (prov?.compositeInstance) node.compositeInstance = prov.compositeInstance;
+    const file = relFile(prov?.sourceFile, projectPath);
+    if (file) node.sourceLoc = { file };
+    nodes.push(node);
+
+    (byLexicon[entity.lexicon] ??= []).push(name);
+    if (prov?.composite) (byComposite[prov.composite] ??= []).push(name);
+  }
+
+  const edgeMap = new Map<string, IREdge>();
+  for (const [name, entity] of entities) {
+    if (!nodeIds.has(name)) continue;
+    for (const e of collectEdges(entity, name, nodeIds, reverse)) {
+      edgeMap.set(edgeKey(e), e);
+    }
+  }
+
+  nodes.sort((a, b) => a.id.localeCompare(b.id));
+  const edges = [...edgeMap.values()].sort((a, b) => edgeKey(a).localeCompare(edgeKey(b)));
+  for (const ids of Object.values(byLexicon)) ids.sort();
+  for (const ids of Object.values(byComposite)) ids.sort();
+
+  const groups: IRGroups = {};
+  if (Object.keys(byLexicon).length) groups.byLexicon = sortKeys(byLexicon);
+  if (Object.keys(byComposite).length) groups.byComposite = sortKeys(byComposite);
+
+  return { nodes, edges, groups };
+}
+
+function sortKeys(rec: Record<string, string[]>): Record<string, string[]> {
+  const out: Record<string, string[]> = {};
+  for (const k of Object.keys(rec).sort()) out[k] = rec[k];
+  return out;
+}

package/src/index.ts

@@ -25,6 +25,8 @@ export * from "./discovery/graph";
 export * from "./discovery/index";
 export * from "./discovery/cache";
 export * from "./build";
+export * from "./graph-ir";
+export * from "./graph-detail";
 export * from "./detectLexicon";
 export * from "./lint/parser";
 export * from "./lint/rule";

package/src/provenance.ts

@@ -15,8 +15,15 @@ const PROVENANCE = Symbol.for("chant.provenance");
 export interface EntityProvenance {
   /** Absolute path of the source file that declared (or exported) the entity. */
   sourceFile?: string;
-  /** The composite that expanded this entity, when it came from one. */
+  /** The composite (type) that expanded this entity, when it came from one. */
   composite?: string;
+  /**
+   * The composite *instance* this entity belongs to — the export name of the
+   * top-level composite, shared by every member it expanded to. Distinguishes
+   * two instances of the same composite type, which `composite` cannot. Used to
+   * collapse a composite to a single node at coarse diagram detail levels (#494).
+   */
+  compositeInstance?: string;
 }
 
 /**
@@ -30,6 +37,7 @@ export function setProvenance(entity: object, prov: EntityProvenance): void {
   if (existing) {
     existing.sourceFile ??= prov.sourceFile;
     existing.composite ??= prov.composite;
+    existing.compositeInstance ??= prov.compositeInstance;
     return;
   }
   Object.defineProperty(entity, PROVENANCE, {