@lucid-evolution/tx-graph 0.0.1

package/dist/index.cjs

@@ -0,0 +1,4292 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildSemanticRenderGraph: () => buildSemanticRenderGraph,
+  createResolutionCache: () => createResolutionCache,
+  createTxGraph: () => createTxGraph,
+  describeRedeemerByConstructor: () => describeRedeemerByConstructor,
+  describeRedeemerWith: () => describeRedeemerWith,
+  genesisUtxo: () => genesisUtxo,
+  labelRedeemer: () => labelRedeemer,
+  outRefKey: () => outRefKey,
+  parseOutRefKey: () => parseOutRefKey,
+  parseTransaction: () => parseTransaction,
+  parseTransactionCbor: () => parseTransactionCbor,
+  producedUtxosFromTransaction: () => producedUtxosFromTransaction,
+  resolveVisualRendererOptions: () => resolveVisualRendererOptions,
+  semanticSvgForTesting: () => semanticSvgForTesting,
+  tagByAddress: () => tagByAddress,
+  tagByCredential: () => tagByCredential,
+  tagByDatum: () => tagByDatum,
+  tagByDatumHash: () => tagByDatumHash,
+  tagByPolicyId: () => tagByPolicyId,
+  tagByScriptRef: () => tagByScriptRef,
+  tagByUnit: () => tagByUnit,
+  tagChange: () => tagChange,
+  toTraceTxOutput: () => toTraceTxOutput,
+  toTraceUtxo: () => toTraceUtxo,
+  traceToDot: () => traceToDot,
+  traceToHtml: () => traceToHtml,
+  traceToJSON: () => traceToJSON,
+  traceToMermaid: () => traceToMermaid,
+  traceToSvg: () => traceToSvg,
+  unresolvedUtxo: () => unresolvedUtxo,
+  visualEdgeStyle: () => visualEdgeStyle,
+  wrapProvider: () => wrapProvider
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/parse.ts
+var import_utils = require("@lucid-evolution/utils");
+
+// src/core.ts
+var CML = __toESM(require("@anastasia-labs/cardano-multiplatform-lib-nodejs"), 1);
+
+// src/parse.ts
+var parseTransaction = (input, options = {}) => {
+  const tx = normalizeTransaction(input);
+  const body = tx.body();
+  const hash = CML.hash_transaction(body).to_hex();
+  const outputs = parseOutputs(hash, body.outputs());
+  const mint = parseMint(body.mint());
+  const splitMint = splitMintAssets(mint);
+  const auxiliaryDataHash = body.auxiliary_data_hash()?.to_hex();
+  return {
+    hash,
+    label: options.label,
+    status: options.status ?? "built",
+    cbor: tx.to_cbor_hex(),
+    sizeBytes: tx.to_cbor_bytes().length,
+    fee: body.fee().toString(),
+    validityInterval: {
+      validFrom: body.validity_interval_start()?.toString(),
+      validTo: body.ttl()?.toString()
+    },
+    inputs: parseInputList(body.inputs()),
+    referenceInputs: parseInputList(body.reference_inputs()),
+    collateralInputs: parseInputList(body.collateral_inputs()),
+    collateralReturn: parseOptionalOutput(body.collateral_return()),
+    totalCollateral: body.total_collateral()?.toString(),
+    outputs,
+    mint,
+    mintedAssets: splitMint.mintedAssets,
+    burnedAssets: splitMint.burnedAssets,
+    withdrawals: parseWithdrawals(body.withdrawals()),
+    certificates: parseCertificates(body.certs()),
+    redeemers: parseRedeemers(tx.witness_set().redeemers()),
+    requiredSigners: parseRequiredSigners(body.required_signers()),
+    auxiliaryDataHash
+  };
+};
+var parseTransactionCbor = (cbor, options = {}) => parseTransaction(cbor, options);
+var normalizeTransaction = (input) => {
+  if (typeof input === "string") {
+    return CML.Transaction.from_cbor_hex(input);
+  }
+  if (hasToTransaction(input)) {
+    return input.toTransaction();
+  }
+  if (isCmlTransaction(input)) {
+    return input;
+  }
+  if (hasToCBOR(input)) {
+    return CML.Transaction.from_cbor_hex(input.toCBOR({ canonical: false }));
+  }
+  throw new TypeError("Unsupported transaction input");
+};
+var hasToTransaction = (input) => typeof input === "object" && input !== null && "toTransaction" in input && typeof input.toTransaction === "function";
+var hasToCBOR = (input) => typeof input === "object" && input !== null && "toCBOR" in input && typeof input.toCBOR === "function";
+var isCmlTransaction = (input) => typeof input === "object" && input !== null && "body" in input && "witness_set" in input && typeof input.body === "function" && typeof input.witness_set === "function";
+var parseInputList = (inputs) => {
+  if (!inputs) return [];
+  const result = [];
+  for (let index = 0; index < inputs.len(); index++) {
+    result.push((0, import_utils.coreToOutRef)(inputs.get(index)));
+  }
+  return result;
+};
+var parseOutputs = (txHash, outputs) => {
+  const result = [];
+  for (let index = 0; index < outputs.len(); index++) {
+    result.push({
+      txHash,
+      outputIndex: index,
+      ...parseTxOutput(outputs.get(index)),
+      resolution: "resolved",
+      tags: []
+    });
+  }
+  return result;
+};
+var parseOptionalOutput = (output) => output ? parseTxOutput(output) : void 0;
+var parseTxOutput = (output) => {
+  const txOutput = (0, import_utils.coreToTxOutput)(output);
+  const credentials = credentialsOf(txOutput.address);
+  return {
+    address: txOutput.address,
+    paymentCredential: credentials.paymentCredential,
+    stakeCredential: credentials.stakeCredential,
+    assets: traceAssets(txOutput.assets),
+    datumHash: txOutput.datumHash ?? void 0,
+    datum: txOutput.datum ?? void 0,
+    scriptRef: txOutput.scriptRef ? traceScriptRef(txOutput.scriptRef) : void 0
+  };
+};
+var credentialsOf = (address) => {
+  try {
+    const { paymentCredential, stakeCredential } = (0, import_utils.getAddressDetails)(address);
+    return {
+      paymentCredential: paymentCredential ?? void 0,
+      stakeCredential: stakeCredential ?? void 0
+    };
+  } catch {
+    return {};
+  }
+};
+var traceAssets = (assets) => {
+  const result = {};
+  for (const unit of Object.keys(assets).sort()) {
+    result[unit] = assets[unit].toString();
+  }
+  return result;
+};
+var traceScriptRef = (script) => ({
+  type: script.type,
+  hash: scriptHash(script),
+  sizeBytes: script.script.length / 2
+});
+var scriptHash = (script) => {
+  try {
+    switch (script.type) {
+      case "Native":
+        return CML.NativeScript.from_cbor_hex(script.script).hash().to_hex();
+      case "PlutusV1":
+        return CML.PlutusScript.from_v1(
+          CML.PlutusV1Script.from_cbor_hex(script.script)
+        ).hash().to_hex();
+      case "PlutusV2":
+        return CML.PlutusScript.from_v2(
+          CML.PlutusV2Script.from_cbor_hex(script.script)
+        ).hash().to_hex();
+      case "PlutusV3":
+        return CML.PlutusScript.from_v3(
+          CML.PlutusV3Script.from_cbor_hex(script.script)
+        ).hash().to_hex();
+    }
+  } catch {
+    return void 0;
+  }
+};
+var parseMint = (mint) => {
+  const assets = {};
+  if (!mint) return {};
+  const policies = mint.keys();
+  for (let policyIndex = 0; policyIndex < policies.len(); policyIndex++) {
+    const policy = policies.get(policyIndex);
+    const policyId = policy.to_hex();
+    const policyAssets = mint.get_assets(policy);
+    if (!policyAssets) continue;
+    const assetNames = policyAssets.keys();
+    for (let assetIndex = 0; assetIndex < assetNames.len(); assetIndex++) {
+      const assetName2 = assetNames.get(assetIndex);
+      const quantity = policyAssets.get(assetName2);
+      if (quantity === void 0 || quantity === 0n) continue;
+      assets[policyId + assetName2.to_js_value()] = quantity;
+    }
+  }
+  return traceAssets(assets);
+};
+var splitMintAssets = (mint) => {
+  const mintedAssets = {};
+  const burnedAssets = {};
+  for (const unit of Object.keys(mint).sort()) {
+    const quantity = BigInt(mint[unit]);
+    if (quantity > 0n) {
+      mintedAssets[unit] = quantity.toString();
+    } else if (quantity < 0n) {
+      burnedAssets[unit] = (-quantity).toString();
+    }
+  }
+  return { mintedAssets, burnedAssets };
+};
+var parseWithdrawals = (withdrawals) => {
+  if (!withdrawals) return [];
+  const result = [];
+  const rewardAccounts = withdrawals.keys();
+  for (let index = 0; index < rewardAccounts.len(); index++) {
+    const rewardAccount = rewardAccounts.get(index);
+    const amount = withdrawals.get(rewardAccount);
+    if (amount === void 0) continue;
+    result.push({
+      rewardAddress: rewardAccount.to_address().to_bech32(void 0),
+      amount: amount.toString()
+    });
+  }
+  return result;
+};
+var parseCertificates = (certificates) => {
+  if (!certificates) return [];
+  const result = [];
+  for (let index = 0; index < certificates.len(); index++) {
+    const certificate = certificates.get(index);
+    const kind = certificate.kind();
+    result.push({
+      index,
+      kind,
+      kindName: certificateKindName(kind),
+      cbor: cborHex(certificate)
+    });
+  }
+  return result;
+};
+var certificateKindName = (kind) => {
+  for (const [name, value] of Object.entries(CML.CertificateKind)) {
+    if (typeof value === "number" && value === kind) return name;
+  }
+  return `Unknown(${kind})`;
+};
+var parseRequiredSigners = (signers) => {
+  if (!signers) return [];
+  const result = [];
+  for (let index = 0; index < signers.len(); index++) {
+    result.push(signers.get(index).to_hex());
+  }
+  return result;
+};
+var parseRedeemers = (redeemers) => {
+  if (!redeemers) return [];
+  return canonicalRedeemerEntries(redeemers).map(
+    (entry, redeemerListIndex) => ({
+      tag: (0, import_utils.fromCMLRedeemerTag)(entry.tag),
+      index: entry.index.toString(),
+      redeemerListIndex,
+      data: entry.data.to_cbor_hex(),
+      exUnits: {
+        mem: entry.exUnits.mem().toString(),
+        steps: entry.exUnits.steps().toString()
+      }
+    })
+  );
+};
+var canonicalRedeemerEntries = (redeemers) => {
+  const entries = [];
+  const legacyRedeemers = redeemers.as_arr_legacy_redeemer();
+  if (legacyRedeemers) {
+    for (let index = 0; index < legacyRedeemers.len(); index++) {
+      const redeemer = legacyRedeemers.get(index);
+      const tag = redeemer.tag();
+      const redeemerIndex = redeemer.index();
+      entries.push({
+        tag,
+        index: redeemerIndex,
+        data: redeemer.data(),
+        exUnits: redeemer.ex_units(),
+        sortKey: redeemerKeyBytes(tag, redeemerIndex)
+      });
+    }
+  }
+  const mapRedeemers = redeemers.as_map_redeemer_key_to_redeemer_val();
+  if (mapRedeemers) {
+    const keys = mapRedeemers.keys();
+    for (let index = 0; index < keys.len(); index++) {
+      const key = keys.get(index);
+      const value = mapRedeemers.get(key);
+      if (!value) continue;
+      const tag = key.tag();
+      const redeemerIndex = key.index();
+      entries.push({
+        tag,
+        index: redeemerIndex,
+        data: value.data(),
+        exUnits: value.ex_units(),
+        sortKey: redeemerKeyBytes(tag, redeemerIndex)
+      });
+    }
+  }
+  return entries.sort(
+    (left, right) => compareBytes(left.sortKey, right.sortKey)
+  );
+};
+var redeemerKeyBytes = (tag, index) => CML.RedeemerKey.new(tag, index).to_canonical_cbor_bytes();
+var compareBytes = (left, right) => {
+  if (left.length !== right.length) return left.length - right.length;
+  for (let index = 0; index < left.length; index++) {
+    if (left[index] !== right[index]) return left[index] - right[index];
+  }
+  return 0;
+};
+var cborHex = (value) => {
+  try {
+    return value.to_cbor_hex?.();
+  } catch {
+    return void 0;
+  }
+};
+
+// src/resolve.ts
+var import_utils2 = require("@lucid-evolution/utils");
+var createResolutionCache = () => {
+  const producedUtxos = /* @__PURE__ */ new Map();
+  const knownUtxos = /* @__PURE__ */ new Map();
+  const addProducedUtxos = (utxos) => {
+    for (const utxo of utxos) {
+      producedUtxos.set(outRefKey(utxo), normalizeTraceUtxo(utxo));
+    }
+  };
+  const addResolvedUtxos = (utxos) => {
+    for (const utxo of utxos) {
+      const traceUtxo = normalizeResolvedUtxo(utxo);
+      knownUtxos.set(outRefKey(traceUtxo), traceUtxo);
+    }
+  };
+  return {
+    addProducedUtxos,
+    addTransactionOutputs: (transaction) => addProducedUtxos(producedUtxosFromTransaction(transaction)),
+    addResolvedUtxos,
+    getProducedUtxo: (outRef) => producedUtxos.get(outRefKey(outRef)),
+    getKnownUtxo: (outRef) => knownUtxos.get(outRefKey(outRef)),
+    resolveOutRefs: (outRefs, options = {}) => resolveOutRefs(outRefs, {
+      ...options,
+      producedUtxos,
+      knownUtxos
+    })
+  };
+};
+var outRefKey = (outRef) => `${outRef.txHash}#${outRef.outputIndex}`;
+var parseOutRefKey = (key) => {
+  const separator = key.lastIndexOf("#");
+  if (separator < 1) throw new Error(`Invalid out ref key: ${key}`);
+  const outputIndex = Number(key.slice(separator + 1));
+  if (!Number.isInteger(outputIndex) || outputIndex < 0) {
+    throw new Error(`Invalid out ref key: ${key}`);
+  }
+  return {
+    txHash: key.slice(0, separator),
+    outputIndex
+  };
+};
+var producedUtxosFromTransaction = (transaction) => transaction.outputs.map((utxo) => normalizeTraceUtxo(utxo));
+var toTraceUtxo = (utxo, options = {}) => ({
+  txHash: utxo.txHash,
+  outputIndex: utxo.outputIndex,
+  ...toTraceTxOutput(utxo),
+  resolution: options.resolution ?? "resolved",
+  unresolvedReason: options.unresolvedReason,
+  tags: [...options.tags ?? []]
+});
+var toTraceTxOutput = (output) => {
+  const credentials = credentialsOf2(output.address);
+  return {
+    address: output.address,
+    paymentCredential: credentials.paymentCredential,
+    stakeCredential: credentials.stakeCredential,
+    assets: traceAssets2(output.assets),
+    datumHash: output.datumHash ?? void 0,
+    datum: output.datum ?? void 0,
+    scriptRef: output.scriptRef ? traceScriptRef2(output.scriptRef) : void 0
+  };
+};
+var unresolvedUtxo = (outRef, reason) => ({
+  txHash: outRef.txHash,
+  outputIndex: outRef.outputIndex,
+  address: "unresolved",
+  assets: {},
+  resolution: "unresolved",
+  unresolvedReason: reason,
+  tags: []
+});
+var genesisUtxo = (outRef) => ({
+  txHash: outRef.txHash,
+  outputIndex: outRef.outputIndex,
+  address: "genesis",
+  assets: {},
+  resolution: "genesis",
+  tags: ["genesis"]
+});
+var resolveOutRefs = async (outRefs, options) => {
+  const requested = uniqueOutRefs(outRefs);
+  const requestedKeys = new Set(requested.map(outRefKey));
+  const resolved = /* @__PURE__ */ new Map();
+  const sources = {};
+  const missReasons = /* @__PURE__ */ new Map();
+  const warnings = [];
+  const recordResolved = (utxo, source) => {
+    const traceUtxo = source === "genesis" ? normalizeGenesisUtxo(utxo) : normalizeResolvedUtxo(utxo);
+    const key = outRefKey(traceUtxo);
+    if (!requestedKeys.has(key) || resolved.has(key)) return;
+    resolved.set(key, traceUtxo);
+    sources[key] = source;
+    missReasons.delete(key);
+  };
+  for (const outRef of requested) {
+    if (!isGenesisOutRef(outRef)) continue;
+    const knownGenesisUtxo = options.knownUtxos?.get(outRefKey(outRef));
+    recordResolved(knownGenesisUtxo ?? genesisUtxo(outRef), "genesis");
+  }
+  for (const outRef of requested) {
+    const utxo = options.producedUtxos?.get(outRefKey(outRef));
+    if (utxo) recordResolved(utxo, "scenario-cache");
+  }
+  let missing = unresolvedOutRefs(requested, resolved);
+  if (missing.length > 0) {
+    if (options.provider) {
+      try {
+        const providerUtxos = await options.provider.getUtxosByOutRef(
+          missing.map(toProviderOutRef)
+        );
+        for (const utxo of providerUtxos) {
+          recordResolved(utxo, "provider");
+        }
+        for (const outRef of unresolvedOutRefs(missing, resolved)) {
+          missReasons.set(outRefKey(outRef), "provider-miss");
+        }
+      } catch (error) {
+        const message = errorMessage(error);
+        warnings.push({
+          code: "provider-resolution-error",
+          message
+        });
+        for (const outRef of missing) {
+          missReasons.set(outRefKey(outRef), "provider-error");
+        }
+      }
+    } else {
+      for (const outRef of missing) {
+        missReasons.set(outRefKey(outRef), "missing-provider");
+      }
+    }
+  }
+  missing = unresolvedOutRefs(requested, resolved);
+  for (const outRef of missing) {
+    const utxo = options.knownUtxos?.get(outRefKey(outRef));
+    if (utxo) recordResolved(utxo, "known-utxos");
+  }
+  missing = unresolvedOutRefs(requested, resolved);
+  if (missing.length > 0 && options.resolver) {
+    try {
+      const resolverUtxos = await options.resolver([...missing]);
+      for (const utxo of resolverUtxos) {
+        recordResolved(utxo, "resolver");
+      }
+      for (const outRef of unresolvedOutRefs(missing, resolved)) {
+        missReasons.set(outRefKey(outRef), "resolver-miss");
+      }
+    } catch (error) {
+      const message = errorMessage(error);
+      warnings.push({
+        code: "resolver-resolution-error",
+        message
+      });
+      for (const outRef of missing) {
+        missReasons.set(outRefKey(outRef), "resolver-error");
+      }
+    }
+  }
+  const utxos = outRefs.map((outRef) => {
+    const key = outRefKey(outRef);
+    const utxo = resolved.get(key);
+    if (utxo) return utxo;
+    sources[key] = "unresolved";
+    return unresolvedUtxo(outRef, missReasons.get(key) ?? "unresolved");
+  });
+  return { utxos, sources, warnings };
+};
+var uniqueOutRefs = (outRefs) => {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const outRef of outRefs) {
+    const key = outRefKey(outRef);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(outRef);
+  }
+  return result;
+};
+var unresolvedOutRefs = (outRefs, resolved) => outRefs.filter((outRef) => !resolved.has(outRefKey(outRef)));
+var toProviderOutRef = (outRef) => ({
+  txHash: outRef.txHash,
+  outputIndex: outRef.outputIndex
+});
+var isGenesisOutRef = (outRef) => /^0{64}$/.test(outRef.txHash);
+var normalizeResolvedUtxo = (utxo) => {
+  const traceUtxo = isTraceUtxo(utxo) ? normalizeTraceUtxo({ ...utxo, resolution: "resolved" }) : toTraceUtxo(utxo);
+  return isGenesisOutRef(traceUtxo) ? normalizeGenesisUtxo(traceUtxo) : traceUtxo;
+};
+var normalizeGenesisUtxo = (utxo) => {
+  const traceUtxo = isTraceUtxo(utxo) ? normalizeTraceUtxo(utxo) : toTraceUtxo(utxo);
+  return normalizeTraceUtxo({
+    ...traceUtxo,
+    resolution: "genesis",
+    unresolvedReason: void 0,
+    tags: [.../* @__PURE__ */ new Set(["genesis", ...traceUtxo.tags])]
+  });
+};
+var normalizeTraceUtxo = (utxo) => ({
+  ...utxo,
+  assets: sortedTraceAssets(utxo.assets),
+  tags: [...utxo.tags].sort()
+});
+var isTraceUtxo = (utxo) => "resolution" in utxo && "tags" in utxo;
+var credentialsOf2 = (address) => {
+  try {
+    const { paymentCredential, stakeCredential } = (0, import_utils2.getAddressDetails)(address);
+    return {
+      paymentCredential: paymentCredential ?? void 0,
+      stakeCredential: stakeCredential ?? void 0
+    };
+  } catch {
+    return {};
+  }
+};
+var traceAssets2 = (assets) => {
+  const result = {};
+  for (const unit of Object.keys(assets).sort()) {
+    result[unit] = assets[unit].toString();
+  }
+  return result;
+};
+var sortedTraceAssets = (assets) => {
+  const result = {};
+  for (const unit of Object.keys(assets).sort()) {
+    result[unit] = assets[unit];
+  }
+  return result;
+};
+var traceScriptRef2 = (script) => ({
+  type: script.type,
+  hash: scriptHash2(script),
+  sizeBytes: script.script.length / 2
+});
+var scriptHash2 = (script) => {
+  try {
+    switch (script.type) {
+      case "Native":
+        return CML.NativeScript.from_cbor_hex(script.script).hash().to_hex();
+      case "PlutusV1":
+        return CML.PlutusScript.from_v1(
+          CML.PlutusV1Script.from_cbor_hex(script.script)
+        ).hash().to_hex();
+      case "PlutusV2":
+        return CML.PlutusScript.from_v2(
+          CML.PlutusV2Script.from_cbor_hex(script.script)
+        ).hash().to_hex();
+      case "PlutusV3":
+        return CML.PlutusScript.from_v3(
+          CML.PlutusV3Script.from_cbor_hex(script.script)
+        ).hash().to_hex();
+    }
+  } catch {
+    return void 0;
+  }
+};
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+
+// src/render/common.ts
+var buildRenderGraph = (trace) => {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const transaction of trace.transactions) {
+    nodes.set(txNodeId(transaction.hash), {
+      id: txNodeId(transaction.hash),
+      kind: "transaction",
+      label: transactionLabel(transaction, trace)
+    });
+  }
+  for (const [key, utxo] of Object.entries(trace.utxos).sort(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    nodes.set(utxoNodeId(utxo), {
+      id: utxoNodeId(utxo),
+      kind: "utxo",
+      label: utxoLabel(key, utxo, trace),
+      unresolved: utxo.resolution === "unresolved",
+      genesis: utxo.resolution === "genesis"
+    });
+  }
+  for (const edge of sortedEdges(trace.edges)) {
+    ensureEndpointNode(nodes, edge.from, trace);
+    ensureEndpointNode(nodes, edge.to, trace);
+  }
+  return {
+    nodes: [...nodes.values()].sort(
+      (left, right) => left.id.localeCompare(right.id)
+    ),
+    edges: sortedEdges(trace.edges)
+  };
+};
+var sortedEdges = (edges) => [...edges].sort(
+  (left, right) => edgeSortKey(left).localeCompare(edgeSortKey(right))
+);
+var edgeStyle = (kind) => {
+  switch (kind) {
+    case "spends":
+      return { label: "spends", color: "#374151", style: "solid" };
+    case "reads":
+      return { label: "reads", color: "#2563eb", style: "dashed" };
+    case "collateral":
+      return { label: "collateral", color: "#d97706", style: "dashed" };
+    case "collateralReturn":
+      return { label: "collateral return", color: "#f59e0b", style: "solid" };
+    case "produces":
+      return { label: "produces", color: "#15803d", style: "solid" };
+    case "mints":
+      return { label: "mints", color: "#7c3aed", style: "solid" };
+    case "burns":
+      return { label: "burns", color: "#dc2626", style: "solid" };
+    case "withdraws":
+      return { label: "withdraws", color: "#0891b2", style: "solid" };
+    case "certifies":
+      return { label: "certifies", color: "#4f46e5", style: "solid" };
+    case "requiresSigner":
+      return { label: "requires signer", color: "#6b7280", style: "dotted" };
+  }
+};
+var txNodeId = (txHash) => `tx:${txHash}`;
+var utxoNodeId = (outRef) => `utxo:${outRefKey(outRef)}`;
+var shortHash = (value, size = 8) => value.length <= size * 2 ? value : `${value.slice(0, size)}...${value.slice(-size)}`;
+var assetName = (unit, trace) => {
+  const alias = trace.aliases.assets[unit];
+  if (alias) return alias;
+  if (unit === "lovelace") return "lovelace";
+  return shortHash(unit, 6);
+};
+var addressName = (address, trace) => trace.aliases.addresses[address] ?? shortHash(address, 10);
+var formatAssets = (assets, trace, options = {}) => {
+  const units = Object.keys(assets).sort(assetUnitSort);
+  const maxAssets = options.maxAssets ?? 4;
+  const visible = units.slice(0, maxAssets);
+  const rendered = visible.map(
+    (unit) => `${assets[unit]} ${assetName(unit, trace)}`
+  );
+  if (units.length > visible.length) {
+    rendered.push(`+${units.length - visible.length} more`);
+  }
+  return rendered.length > 0 ? rendered.join("\\n") : "no assets";
+};
+var transactionLabel = (transaction, trace) => {
+  const lines = [
+    transaction.label ?? `tx ${shortHash(transaction.hash)}`,
+    `status: ${transaction.status}`,
+    `fee: ${transaction.fee}`
+  ];
+  if (Object.keys(transaction.mintedAssets).length > 0) {
+    lines.push(`mint: ${formatAssets(transaction.mintedAssets, trace)}`);
+  }
+  if (Object.keys(transaction.burnedAssets).length > 0) {
+    lines.push(`burn: ${formatAssets(transaction.burnedAssets, trace)}`);
+  }
+  const warningCount = trace.warnings.filter(
+    (warning) => warning.txHash === transaction.hash
+  ).length;
+  if (warningCount > 0) lines.push(`warnings: ${warningCount}`);
+  return lines.join("\\n");
+};
+var utxoLabel = (key, utxo, trace) => {
+  if (utxo.resolution === "genesis") {
+    const lines2 = ["genesis UTxO", key];
+    if (Object.keys(utxo.assets).length > 0) {
+      lines2.push(formatAssets(utxo.assets, trace));
+    }
+    lines2.push("external funding source");
+    return lines2.join("\\n");
+  }
+  const lines = [
+    utxo.tags.length > 0 ? `[${utxo.tags.join(", ")}]` : key,
+    formatAssets(utxo.assets, trace),
+    addressName(utxo.address, trace)
+  ];
+  if (utxo.datum) {
+    lines.push("inline datum");
+  } else if (utxo.datumHash) {
+    lines.push(`datum ${shortHash(utxo.datumHash)}`);
+  }
+  if (utxo.scriptRef) {
+    lines.push(
+      `script ref ${utxo.scriptRef.type}${utxo.scriptRef.hash ? ` ${shortHash(utxo.scriptRef.hash)}` : ""}`
+    );
+  }
+  if (utxo.resolution === "unresolved") {
+    lines.push(`unresolved: ${utxo.unresolvedReason ?? "unknown"}`);
+  }
+  return lines.join("\\n");
+};
+var externalNodeLabel = (nodeId, trace) => {
+  if (nodeId.startsWith("asset:")) {
+    return assetName(nodeId.slice("asset:".length), trace);
+  }
+  if (nodeId.startsWith("withdrawal:")) {
+    return `withdrawal\\n${addressName(nodeId.slice("withdrawal:".length), trace)}`;
+  }
+  if (nodeId.startsWith("signer:")) {
+    return `signer\\n${shortHash(nodeId.slice("signer:".length))}`;
+  }
+  if (nodeId.startsWith("collateral-return:")) {
+    return `collateral return\\n${shortHash(
+      nodeId.slice("collateral-return:".length)
+    )}`;
+  }
+  if (nodeId.startsWith("certificate:")) {
+    const { txHash, index } = parseIndexedNode(
+      nodeId.slice("certificate:".length)
+    );
+    const certificate = trace.transactions.find((transaction) => transaction.hash === txHash)?.certificates.find((candidate) => candidate.index === index);
+    return certificate ? `certificate\\n${certificate.kindName}` : `certificate\\n${shortHash(txHash)}#${index}`;
+  }
+  return nodeId;
+};
+var ensureEndpointNode = (nodes, nodeId, trace) => {
+  if (nodes.has(nodeId)) return;
+  nodes.set(nodeId, {
+    id: nodeId,
+    kind: externalNodeKind(nodeId),
+    label: externalNodeLabel(nodeId, trace)
+  });
+};
+var externalNodeKind = (nodeId) => {
+  if (nodeId.startsWith("asset:")) return "asset";
+  if (nodeId.startsWith("withdrawal:")) return "withdrawal";
+  if (nodeId.startsWith("certificate:")) return "certificate";
+  if (nodeId.startsWith("signer:")) return "signer";
+  if (nodeId.startsWith("collateral-return:")) return "collateralReturn";
+  return "external";
+};
+var edgeSortKey = (edge) => `${edge.from}\0${edge.kind}\0${edge.to}`;
+var assetUnitSort = (left, right) => {
+  if (left === "lovelace") return -1;
+  if (right === "lovelace") return 1;
+  return left.localeCompare(right);
+};
+var parseIndexedNode = (value) => {
+  const separator = value.lastIndexOf("#");
+  return {
+    txHash: separator >= 0 ? value.slice(0, separator) : value,
+    index: separator >= 0 ? Number(value.slice(separator + 1)) : 0
+  };
+};
+
+// src/render/options.ts
+var resolveVisualRendererOptions = (options = {}) => {
+  const mode = options.mode ?? "overview";
+  return {
+    mode,
+    view: options.view ?? "flow",
+    privacy: { ...privacyByMode[mode], ...options.privacy },
+    budget: { ...budgetByMode[mode], ...options.budget }
+  };
+};
+var visualEdgeStyle = (kind) => {
+  switch (kind) {
+    case "spend":
+      return { color: "#374151", style: "solid" };
+    case "read":
+      return { color: "#2563eb", style: "dashed" };
+    case "collateral":
+      return { color: "#d97706", style: "dashed" };
+    case "collateralReturn":
+      return { color: "#f59e0b", style: "solid" };
+    case "produce":
+      return { color: "#15803d", style: "solid" };
+    case "mint":
+      return { color: "#7c3aed", style: "solid" };
+    case "burn":
+      return { color: "#dc2626", style: "solid" };
+    case "withdraw":
+      return { color: "#0891b2", style: "solid" };
+    case "certify":
+      return { color: "#4f46e5", style: "solid" };
+    case "sign":
+      return { color: "#6b7280", style: "dotted" };
+    case "diagnostic":
+      return { color: "#dc2626", style: "dashed" };
+    case "summary":
+      return { color: "#6b7280", style: "dashed" };
+    default:
+      return { color: "#6b7280", style: "solid" };
+  }
+};
+var privacyByMode = {
+  overview: {
+    hash: "short",
+    address: "alias",
+    datum: "marker",
+    redeemer: "label",
+    cbor: "hidden"
+  },
+  audit: {
+    hash: "short",
+    address: "alias",
+    datum: "hash",
+    redeemer: "constructor",
+    cbor: "prefix"
+  },
+  debug: {
+    hash: "full",
+    address: "full",
+    datum: "full",
+    redeemer: "full",
+    cbor: "prefix"
+  }
+};
+var budgetByMode = {
+  overview: {
+    maxVisibleInputs: 4,
+    maxVisibleOutputs: 4,
+    maxVisibleAssetsPerUtxo: 4,
+    maxVisibleSigners: 3,
+    maxVisibleWarnings: 3,
+    maxVisibleRedeemerFields: 2
+  },
+  audit: {
+    maxVisibleInputs: 12,
+    maxVisibleOutputs: 12,
+    maxVisibleAssetsPerUtxo: 12,
+    maxVisibleSigners: 8,
+    maxVisibleWarnings: 8,
+    maxVisibleRedeemerFields: 6
+  },
+  debug: {
+    maxVisibleInputs: Number.POSITIVE_INFINITY,
+    maxVisibleOutputs: Number.POSITIVE_INFINITY,
+    maxVisibleAssetsPerUtxo: Number.POSITIVE_INFINITY,
+    maxVisibleSigners: Number.POSITIVE_INFINITY,
+    maxVisibleWarnings: Number.POSITIVE_INFINITY,
+    maxVisibleRedeemerFields: Number.POSITIVE_INFINITY
+  }
+};
+
+// src/render/semantic-format.ts
+var formatSemanticGraph = (graph, options) => {
+  const nodes = new Map(graph.nodes.map((node) => [node.id, node]));
+  const edges = [...graph.edges];
+  applyViewAnnotations(options, nodes);
+  addDiagnosticNodes(graph, options, nodes, edges);
+  addBudgetSummaries(options, nodes, edges);
+  const connectedNodeIds = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    connectedNodeIds.add(edge.from);
+    connectedNodeIds.add(edge.to);
+  }
+  return {
+    nodes: [...nodes.values()].filter(
+      (node) => node.kind === "transaction" || node.kind === "diagnostic" || connectedNodeIds.has(node.id)
+    ).sort((left, right) => left.id.localeCompare(right.id)),
+    edges: edges.sort((left, right) => left.id.localeCompare(right.id))
+  };
+};
+var semanticEdgeLabel = (trace, edge, options) => {
+  if (!edge.redeemerKey || !edge.action) return edge.label;
+  const base = `${edge.redeemerKey.tag} #${edge.redeemerKey.index}`;
+  if (options.privacy.redeemer === "hidden") return base;
+  if (options.mode === "overview" || options.privacy.redeemer === "label") {
+    return edge.action.label;
+  }
+  const redeemer = findRedeemer(trace, edge);
+  const parts = [base];
+  if (edge.action.label !== base) parts.push(edge.action.label);
+  parts.push(`redeemer list #${edge.redeemerKey.redeemerListIndex}`);
+  if (redeemer)
+    parts.push(`ex ${redeemer.exUnits.mem}/${redeemer.exUnits.steps}`);
+  if (options.mode === "debug" || options.privacy.redeemer === "constructor" || options.privacy.redeemer === "full") {
+    parts.push(
+      ...Object.entries(edge.action.fields ?? {}).slice(0, options.budget.maxVisibleRedeemerFields).map(([label, value]) => `${label}: ${value}`)
+    );
+  }
+  if (options.mode === "debug") {
+    parts.push(`${edge.action.source}/${edge.action.confidence}`);
+  }
+  return parts.join(" \xB7 ");
+};
+var semanticChipLabels = (node, options) => {
+  if (node.rawRef.type === "assetPolicy") {
+    return [formatHash(node.rawRef.policyId, options)];
+  }
+  return node.chips.map((chip) => chip.label).filter((label) => node.kind !== "utxo" || label !== "resolved");
+};
+var visibleSemanticSections = (node, options) => {
+  if (options.mode !== "overview") return node.sections;
+  if (node.kind === "transaction") {
+    return node.sections.filter(
+      (section2) => ["facts", "inputs", "assets", "redeemers"].includes(section2.id)
+    );
+  }
+  return node.sections;
+};
+var visibleSemanticRows = (section2, _node, options) => {
+  const maxRows = section2.id === "assets" ? options.budget.maxVisibleAssetsPerUtxo : section2.id === "redeemers" ? options.budget.maxVisibleRedeemerFields : Number.POSITIVE_INFINITY;
+  const rows = section2.rows.slice(0, maxRows);
+  if (section2.rows.length <= rows.length) return rows;
+  return [
+    ...rows,
+    {
+      id: `${section2.id}:more`,
+      label: "More",
+      value: `+${section2.rows.length - rows.length} more`,
+      tone: "neutral"
+    }
+  ];
+};
+var semanticFieldValue = (row, options) => {
+  if (row.id.startsWith("asset:") && row.rawValue) {
+    const defaultShort = shortHash(row.rawValue, 6);
+    if (options.privacy.hash === "hidden" && (row.value === defaultShort || row.value === row.rawValue)) {
+      return "asset";
+    }
+    if (options.privacy.hash === "full" && row.value === defaultShort) {
+      return row.rawValue;
+    }
+  }
+  if (row.id === "address") {
+    switch (options.privacy.address) {
+      case "hidden":
+        return "hidden";
+      case "full":
+        return row.rawValue ?? row.value;
+      case "short":
+        return row.rawValue ? shortHash(row.rawValue, 10) : row.value;
+      case "alias":
+        return row.value;
+    }
+  }
+  if (row.id.startsWith("datum")) {
+    switch (options.privacy.datum) {
+      case "hidden":
+        return "hidden";
+      case "marker":
+        return "present";
+      case "full":
+        return row.rawValue ?? row.value;
+      default:
+        return row.value;
+    }
+  }
+  if (row.id === "keyHash" && row.rawValue) {
+    return formatHash(row.rawValue, options);
+  }
+  if (row.id === "scriptRef" && row.rawValue) {
+    if (options.privacy.hash === "hidden") {
+      return row.rawValue.split(" ")[0] ?? "script ref";
+    }
+    return options.privacy.hash === "full" ? row.rawValue : row.value;
+  }
+  return row.value;
+};
+var semanticFieldLabel = (row, options) => {
+  if (row.id.startsWith("asset:") && row.rawLabel) {
+    const defaultShort = shortHash(row.rawLabel, 6);
+    if (options.privacy.hash === "hidden" && (row.label === defaultShort || row.label === row.rawLabel)) {
+      return "asset";
+    }
+    if (options.privacy.hash === "full" && row.label === defaultShort) {
+      return row.rawLabel;
+    }
+  }
+  return row.label;
+};
+var semanticNodeTitle = (node, options) => {
+  if (node.rawRef.type === "transaction" && node.title === `tx ${shortHash(node.rawRef.txHash)}`) {
+    return `tx ${formatHash(node.rawRef.txHash, options)}`;
+  }
+  if (node.rawRef.type === "utxo" && node.title === outRefKey(node.rawRef.outRef)) {
+    return `UTxO ${formatOutRef(node.rawRef.outRef, options)}`;
+  }
+  if (node.rawRef.type === "assetPolicy" && node.title.startsWith("policy ")) {
+    return `policy ${formatHash(node.rawRef.policyId, options)}`;
+  }
+  return node.title;
+};
+var semanticNodeSubtitle = (node, options) => {
+  if (options.privacy.hash === "hidden") return void 0;
+  switch (node.rawRef.type) {
+    case "transaction":
+      return formatHash(node.rawRef.txHash, options);
+    case "utxo":
+      return formatOutRef(node.rawRef.outRef, options);
+    case "assetPolicy":
+      return formatHash(node.rawRef.policyId, options);
+    case "signer":
+      return formatHash(node.rawRef.keyHash, options);
+    case "withdrawal":
+      return formatAddress(node.rawRef.rewardAddress, node.subtitle, options);
+    case "certificate":
+      return `${formatHash(node.rawRef.txHash, options)}#${node.rawRef.index}`;
+    case "collateralReturn":
+      return formatHash(node.rawRef.txHash, options);
+    default:
+      return node.subtitle;
+  }
+};
+var isGenesisNode = (node) => node.kind === "utxo" && node.chips.some((chip) => chip.label === "genesis");
+var isScriptNode = (node) => node.kind === "utxo" && (node.sections.some(
+  (section2) => section2.rows.some(
+    (row) => ["datum", "datumHash", "scriptRef"].includes(row.id)
+  )
+) || node.chips.some((chip) => /script|datum|state/i.test(chip.label)));
+var isScriptInteractionEdge = (edge, nodes) => ["spend", "read", "produce", "mint", "burn"].includes(edge.kind) && [edge.from, edge.to].some((id) => {
+  const node = nodes.get(id);
+  return node ? isScriptNode(node) : false;
+}) || edge.kind === "collateral";
+var addDiagnosticNodes = (graph, options, nodes, edges) => {
+  const byTx = /* @__PURE__ */ new Map();
+  for (const diagnostic of graph.diagnostics) {
+    const key = diagnostic.txHash ?? "global";
+    byTx.set(key, [...byTx.get(key) ?? [], diagnostic]);
+  }
+  for (const [txHash, diagnostics] of byTx) {
+    const visible = diagnostics.slice(0, options.budget.maxVisibleWarnings);
+    for (const diagnostic of visible) {
+      addDiagnosticNode(options, diagnostic, nodes, edges);
+    }
+    if (diagnostics.length > visible.length) {
+      const hiddenCount = diagnostics.length - visible.length;
+      const node = summaryNode(
+        `summary:${txHash}:diagnostics`,
+        `+${hiddenCount} diagnostics`,
+        "warnings",
+        hiddenCount
+      );
+      nodes.set(node.id, node);
+      if (txHash !== "global") {
+        edges.push(summaryEdge(node.id, `tx:${txHash}`, txHash, "warnings"));
+      }
+    }
+  }
+};
+var applyViewAnnotations = (options, nodes) => {
+  if (options.view !== "scriptInteraction") return;
+  for (const [id, node] of nodes) {
+    if (node.kind !== "utxo" || !isScriptNode(node)) continue;
+    nodes.set(id, {
+      ...node,
+      chips: [
+        { label: "script interaction", tone: "accent" },
+        ...node.chips.filter((chip) => chip.label !== "script interaction")
+      ]
+    });
+  }
+};
+var addDiagnosticNode = (options, diagnostic, nodes, edges) => {
+  const node = {
+    id: `diagnostic:${diagnostic.id}`,
+    kind: "diagnostic",
+    title: diagnostic.code,
+    sections: [
+      {
+        id: "diagnostic",
+        title: "Diagnostic",
+        rows: [
+          {
+            id: "message",
+            label: "Message",
+            value: diagnosticMessage(diagnostic, options)
+          }
+        ]
+      }
+    ],
+    ports: [],
+    chips: [{ label: diagnostic.severity, tone: "danger" }],
+    severity: diagnostic.severity === "error" ? "error" : "warning",
+    rawRef: { type: "diagnostic", code: diagnostic.code }
+  };
+  nodes.set(node.id, node);
+  if (diagnostic.txHash) {
+    edges.push({
+      id: `diagnostic-edge:${diagnostic.id}`,
+      kind: "diagnostic",
+      from: node.id,
+      to: `tx:${diagnostic.txHash}`,
+      label: diagnostic.severity,
+      targetRef: {
+        type: "diagnostic",
+        txHash: diagnostic.txHash,
+        code: diagnostic.code
+      },
+      rawRef: { type: "diagnostic", code: diagnostic.code }
+    });
+  }
+};
+var addBudgetSummaries = (options, nodes, edges) => {
+  const hidden = /* @__PURE__ */ new Set();
+  for (const txHash of transactionHashes(nodes)) {
+    hideExcessEdges(
+      edges,
+      txHash,
+      "inputs",
+      options.budget.maxVisibleInputs,
+      (edge) => edge.targetRef.txHash === txHash && ["spend", "read", "collateral"].includes(edge.kind),
+      hidden,
+      nodes
+    );
+    hideExcessEdges(
+      edges,
+      txHash,
+      "outputs",
+      options.budget.maxVisibleOutputs,
+      (edge) => edge.targetRef.txHash === txHash && edge.kind === "produce",
+      hidden,
+      nodes
+    );
+    hideExcessEdges(
+      edges,
+      txHash,
+      "signers",
+      options.budget.maxVisibleSigners,
+      (edge) => edge.targetRef.txHash === txHash && edge.kind === "sign",
+      hidden,
+      nodes
+    );
+  }
+  for (let index = edges.length - 1; index >= 0; index--) {
+    if (hidden.has(edges[index].id)) edges.splice(index, 1);
+  }
+};
+var hideExcessEdges = (edges, txHash, group, maxVisible, matches, hidden, nodes) => {
+  const visibleLimit = Number.isFinite(maxVisible) ? maxVisible : edges.length;
+  const candidates = edges.filter(matches).sort((left, right) => left.id.localeCompare(right.id));
+  const extra = candidates.slice(visibleLimit);
+  for (const edge of extra) hidden.add(edge.id);
+  if (extra.length === 0) return;
+  const node = summaryNode(
+    `summary:${txHash}:${group}`,
+    `+${extra.length} ${group}`,
+    group,
+    extra.length
+  );
+  nodes.set(node.id, node);
+  edges.push(
+    group === "outputs" ? summaryEdge(`tx:${txHash}`, node.id, txHash, group) : summaryEdge(node.id, `tx:${txHash}`, txHash, group)
+  );
+};
+var summaryNode = (id, title, group, count) => ({
+  id,
+  kind: "diagnostic",
+  title,
+  sections: [
+    {
+      id: "summary",
+      title: "Collapsed",
+      rows: [{ id: "count", label: "Count", value: String(count) }]
+    }
+  ],
+  ports: [],
+  chips: [{ label: "collapsed", tone: "neutral" }],
+  rawRef: { type: "diagnostic", code: "collapsed", count, group }
+});
+var summaryEdge = (from, to, txHash, group) => ({
+  id: `summary-edge:${txHash}:${group}:${from}->${to}`,
+  kind: "summary",
+  from,
+  to,
+  label: group,
+  targetRef: {
+    type: "diagnostic",
+    txHash,
+    code: "collapsed",
+    group
+  },
+  rawRef: { type: "diagnostic", code: "collapsed", group }
+});
+var transactionHashes = (nodes) => [...nodes.values()].filter(
+  (node) => node.rawRef.type === "transaction"
+).map((node) => node.rawRef.txHash).sort();
+var formatOutRef = (outRef, options) => {
+  if (options.privacy.hash === "hidden") return `#${outRef.outputIndex}`;
+  return `${formatHash(outRef.txHash, options)}#${outRef.outputIndex}`;
+};
+var formatHash = (hash, options) => options.privacy.hash === "full" ? hash : options.privacy.hash === "hidden" ? "hidden" : shortHash(hash);
+var formatAddress = (rawAddress, aliasOrShort, options) => {
+  switch (options.privacy.address) {
+    case "hidden":
+      return void 0;
+    case "full":
+      return rawAddress;
+    case "short":
+      return shortHash(rawAddress, 10);
+    case "alias":
+      return aliasOrShort ?? shortHash(rawAddress, 10);
+  }
+};
+var diagnosticMessage = (diagnostic, options) => {
+  let message = diagnostic.message;
+  if (diagnostic.outRef) {
+    message = message.replace(
+      outRefKey(diagnostic.outRef),
+      formatOutRef(diagnostic.outRef, options)
+    );
+  }
+  if (diagnostic.txHash) {
+    message = message.replaceAll(
+      diagnostic.txHash,
+      formatHash(diagnostic.txHash, options)
+    );
+  }
+  return message;
+};
+var findRedeemer = (trace, edge) => {
+  const key = edge.redeemerKey;
+  if (!key) return void 0;
+  return trace.transactions.find((transaction) => transaction.hash === edge.targetRef.txHash)?.redeemers.find(
+    (redeemer) => redeemer.tag === key.tag && redeemer.index === key.index && redeemer.redeemerListIndex === key.redeemerListIndex
+  );
+};
+
+// src/render/semantic.ts
+var buildSemanticRenderGraph = (trace, options = {}) => {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const mappedRedeemers = /* @__PURE__ */ new Set();
+  for (const [key, utxo] of Object.entries(trace.utxos).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    nodes.set(utxoNodeId2(utxo), utxoNode(key, utxo, trace));
+  }
+  for (const transaction of trace.transactions) {
+    nodes.set(
+      transactionNodeId(transaction.hash),
+      transactionNode(transaction, trace)
+    );
+    addTransactionEdges(trace, transaction, nodes, edges, mappedRedeemers);
+  }
+  const diagnostics = [
+    ...trace.warnings.map(visualDiagnostic),
+    ...unmappedRedeemerDiagnostics(trace, mappedRedeemers)
+  ];
+  return {
+    version: 1,
+    nodes: [...nodes.values()].sort(
+      (left, right) => left.id.localeCompare(right.id)
+    ),
+    edges: edges.map((edge) => applyAction(trace, edge, options.redeemers ?? [])).sort((left, right) => left.id.localeCompare(right.id)),
+    diagnostics,
+    legend: defaultLegend,
+    aliases: trace.aliases
+  };
+};
+var labelRedeemer = (selector, label, intent) => (context) => {
+  if (!matchesRedeemer(selector, context)) return void 0;
+  return {
+    label,
+    ...intent ? { intent } : {},
+    source: "user",
+    confidence: "high"
+  };
+};
+var describeRedeemerByConstructor = (selector, label, intent) => (context) => {
+  const { redeemer } = context;
+  if (!matchesRedeemer(selector, context)) return void 0;
+  if (constructorOf(redeemer.data) !== selector.constructor) return void 0;
+  return {
+    label,
+    ...intent ? { intent } : {},
+    fields: { constructor: String(selector.constructor) },
+    source: "constructor",
+    confidence: "medium"
+  };
+};
+var describeRedeemerWith = (describe) => (context) => describe(context);
+var addTransactionEdges = (trace, transaction, nodes, edges, mappedRedeemers) => {
+  addInputEdges(
+    trace,
+    transaction,
+    nodes,
+    edges,
+    mappedRedeemers,
+    "spend",
+    transaction.inputs
+  );
+  addInputEdges(
+    trace,
+    transaction,
+    nodes,
+    edges,
+    mappedRedeemers,
+    "read",
+    transaction.referenceInputs
+  );
+  addInputEdges(
+    trace,
+    transaction,
+    nodes,
+    edges,
+    mappedRedeemers,
+    "collateral",
+    transaction.collateralInputs
+  );
+  addOutputEdges(transaction, edges);
+  addAssetPolicyEdges(
+    trace,
+    transaction,
+    nodes,
+    edges,
+    mappedRedeemers,
+    "mint"
+  );
+  addAssetPolicyEdges(
+    trace,
+    transaction,
+    nodes,
+    edges,
+    mappedRedeemers,
+    "burn"
+  );
+  addWithdrawalEdges(trace, transaction, nodes, edges, mappedRedeemers);
+  addCertificateEdges(transaction, nodes, edges, mappedRedeemers);
+  addSignerEdges(transaction, nodes, edges);
+  addCollateralReturnEdge(transaction, nodes, edges);
+};
+var addInputEdges = (trace, transaction, nodes, edges, mappedRedeemers, kind, inputs) => {
+  inputs.forEach((outRef, index) => {
+    const inputKey = outRefKey(outRef);
+    const from = utxoNodeId2(outRef);
+    const to = transactionNodeId(transaction.hash);
+    const redeemerKey = kind === "spend" ? redeemerKeyFor(transaction, "spend", index, mappedRedeemers) : void 0;
+    ensureUtxoPlaceholder(trace, nodes, outRef);
+    edges.push({
+      id: `${to}:${kind}:${index}:${inputKey}`,
+      kind,
+      from,
+      to,
+      fromPort: utxoPortId(inputKey, "out"),
+      toPort: transactionPortId(transaction.hash, kind, index),
+      label: `${kind} #${index}`,
+      ...redeemerKey ? { redeemerKey } : {},
+      targetRef: {
+        type: "input",
+        inputKind: kind,
+        txHash: transaction.hash,
+        index,
+        outRef
+      },
+      rawRef: { type: "utxo", outRef }
+    });
+  });
+};
+var addOutputEdges = (transaction, edges) => {
+  transaction.outputs.forEach((output, index) => {
+    const outputKey = outRefKey(output);
+    edges.push({
+      id: `${transactionNodeId(transaction.hash)}:produce:${index}`,
+      kind: "produce",
+      from: transactionNodeId(transaction.hash),
+      to: utxoNodeId2(output),
+      fromPort: transactionPortId(transaction.hash, "produce", index),
+      toPort: utxoPortId(outputKey, "in"),
+      label: `output #${index}`,
+      targetRef: {
+        type: "output",
+        txHash: transaction.hash,
+        index,
+        outRef: {
+          txHash: output.txHash,
+          outputIndex: output.outputIndex
+        }
+      },
+      rawRef: {
+        type: "utxo",
+        outRef: {
+          txHash: output.txHash,
+          outputIndex: output.outputIndex
+        }
+      }
+    });
+  });
+};
+var addAssetPolicyEdges = (trace, transaction, nodes, edges, mappedRedeemers, kind) => {
+  const assets = kind === "mint" ? transaction.mintedAssets : transaction.burnedAssets;
+  const byPolicy = assetsByPolicy(assets);
+  const policyIds = sortedPolicyIds(transaction.mint);
+  for (const [policyId, policyAssets] of Object.entries(byPolicy).sort(
+    ([a], [b]) => a.localeCompare(b)
+  )) {
+    const policyIndex = policyIds.indexOf(policyId);
+    const index = policyIndex >= 0 ? policyIndex : 0;
+    const redeemerKey = redeemerKeyFor(
+      transaction,
+      "mint",
+      index,
+      mappedRedeemers
+    );
+    const assetNode = assetPolicyNode(policyId, policyAssets, trace);
+    nodes.set(
+      assetNode.id,
+      mergeAssetPolicyNode(nodes.get(assetNode.id), assetNode)
+    );
+    const edge = {
+      id: `${transactionNodeId(transaction.hash)}:${kind}:${index}:${policyId}`,
+      kind,
+      from: kind === "mint" ? transactionNodeId(transaction.hash) : assetPolicyNodeId(policyId),
+      to: kind === "mint" ? assetPolicyNodeId(policyId) : transactionNodeId(transaction.hash),
+      fromPort: kind === "mint" ? transactionPortId(transaction.hash, "mint", index) : assetPolicyPortId(policyId),
+      toPort: kind === "mint" ? assetPolicyPortId(policyId) : transactionPortId(transaction.hash, "burn", index),
+      label: `${kind} #${index}`,
+      ...redeemerKey ? { redeemerKey } : {},
+      targetRef: {
+        type: "assetPolicy",
+        txHash: transaction.hash,
+        policyId,
+        policyIndex: index,
+        assets: policyAssets
+      },
+      rawRef: { type: "assetPolicy", policyId }
+    };
+    edges.push(edge);
+  }
+};
+var addWithdrawalEdges = (trace, transaction, nodes, edges, mappedRedeemers) => {
+  transaction.withdrawals.forEach((withdrawal, index) => {
+    const node = withdrawalNode(withdrawal.rewardAddress, trace);
+    const redeemerKey = redeemerKeyFor(
+      transaction,
+      "withdraw",
+      index,
+      mappedRedeemers
+    );
+    nodes.set(node.id, node);
+    edges.push({
+      id: `${transactionNodeId(transaction.hash)}:withdraw:${index}:${withdrawal.rewardAddress}`,
+      kind: "withdraw",
+      from: node.id,
+      to: transactionNodeId(transaction.hash),
+      fromPort: withdrawalPortId(withdrawal.rewardAddress),
+      toPort: transactionPortId(transaction.hash, "withdraw", index),
+      label: `withdraw #${index}`,
+      ...redeemerKey ? { redeemerKey } : {},
+      targetRef: {
+        type: "withdrawal",
+        txHash: transaction.hash,
+        index,
+        rewardAddress: withdrawal.rewardAddress
+      },
+      rawRef: { type: "withdrawal", rewardAddress: withdrawal.rewardAddress }
+    });
+  });
+};
+var addCertificateEdges = (transaction, nodes, edges, mappedRedeemers) => {
+  transaction.certificates.forEach((certificate) => {
+    const node = certificateNode(
+      transaction.hash,
+      certificate.index,
+      certificate.kindName
+    );
+    const redeemerKey = redeemerKeyFor(
+      transaction,
+      "publish",
+      certificate.index,
+      mappedRedeemers
+    );
+    nodes.set(node.id, node);
+    edges.push({
+      id: `${transactionNodeId(transaction.hash)}:cert:${certificate.index}`,
+      kind: "certify",
+      from: transactionNodeId(transaction.hash),
+      to: node.id,
+      fromPort: transactionPortId(
+        transaction.hash,
+        "certify",
+        certificate.index
+      ),
+      toPort: certificatePortId(transaction.hash, certificate.index),
+      label: `cert #${certificate.index}`,
+      ...redeemerKey ? { redeemerKey } : {},
+      targetRef: {
+        type: "certificate",
+        txHash: transaction.hash,
+        index: certificate.index
+      },
+      rawRef: {
+        type: "certificate",
+        txHash: transaction.hash,
+        index: certificate.index
+      }
+    });
+  });
+};
+var addSignerEdges = (transaction, nodes, edges) => {
+  transaction.requiredSigners.forEach((keyHash, index) => {
+    const node = signerNode(keyHash);
+    nodes.set(node.id, node);
+    edges.push({
+      id: `${transactionNodeId(transaction.hash)}:signer:${keyHash}`,
+      kind: "sign",
+      from: node.id,
+      to: transactionNodeId(transaction.hash),
+      fromPort: signerPortId(keyHash),
+      toPort: transactionPortId(transaction.hash, "sign", index),
+      label: "requires signer",
+      targetRef: {
+        type: "signer",
+        txHash: transaction.hash,
+        keyHash
+      },
+      rawRef: { type: "signer", keyHash }
+    });
+  });
+};
+var addCollateralReturnEdge = (transaction, nodes, edges) => {
+  if (!transaction.collateralReturn) return;
+  const node = collateralReturnNode(transaction);
+  nodes.set(node.id, node);
+  edges.push({
+    id: `${transactionNodeId(transaction.hash)}:collateral-return`,
+    kind: "collateralReturn",
+    from: transactionNodeId(transaction.hash),
+    to: node.id,
+    fromPort: transactionPortId(transaction.hash, "collateralReturn", 0),
+    toPort: collateralReturnPortId(transaction.hash),
+    label: "collateral return",
+    targetRef: {
+      type: "collateralReturn",
+      txHash: transaction.hash
+    },
+    rawRef: { type: "collateralReturn", txHash: transaction.hash }
+  });
+};
+var transactionNode = (transaction, trace) => {
+  const warningCount = trace.warnings.filter(
+    (warning) => warning.txHash === transaction.hash
+  ).length;
+  return {
+    id: transactionNodeId(transaction.hash),
+    kind: "transaction",
+    title: transaction.label ?? `tx ${shortHash(transaction.hash)}`,
+    subtitle: shortHash(transaction.hash),
+    chips: [
+      { label: transaction.status, tone: statusTone(transaction.status) },
+      ...warningCount > 0 ? [{ label: `${warningCount} warnings`, tone: "warning" }] : []
+    ],
+    sections: [
+      section("facts", "Facts", [
+        field("fee", "Fee", transaction.fee),
+        field("size", "Size", `${transaction.sizeBytes} bytes`),
+        ...transaction.validityInterval.validFrom ? [
+          field(
+            "validFrom",
+            "Valid from",
+            transaction.validityInterval.validFrom
+          )
+        ] : [],
+        ...transaction.validityInterval.validTo ? [field("validTo", "Valid to", transaction.validityInterval.validTo)] : []
+      ]),
+      section("inputs", "Inputs", [
+        field("spend", "Spend", String(transaction.inputs.length)),
+        field("read", "Read", String(transaction.referenceInputs.length)),
+        field(
+          "collateral",
+          "Collateral",
+          String(transaction.collateralInputs.length)
+        )
+      ]),
+      section("assets", "Assets", [
+        field(
+          "mint",
+          "Mint policies",
+          String(sortedPolicyIds(transaction.mintedAssets).length)
+        ),
+        field(
+          "burn",
+          "Burn policies",
+          String(sortedPolicyIds(transaction.burnedAssets).length)
+        )
+      ]),
+      section("authority", "Authority", [
+        field("signers", "Signers", String(transaction.requiredSigners.length)),
+        field(
+          "certificates",
+          "Certificates",
+          String(transaction.certificates.length)
+        ),
+        field(
+          "withdrawals",
+          "Withdrawals",
+          String(transaction.withdrawals.length)
+        )
+      ]),
+      section("redeemers", "Redeemers", [
+        field("redeemers", "Redeemers", String(transaction.redeemers.length))
+      ])
+    ],
+    ports: transactionPorts(transaction),
+    ...transaction.status === "failed" ? { severity: "error" } : {},
+    rawRef: { type: "transaction", txHash: transaction.hash }
+  };
+};
+var utxoNode = (key, utxo, trace) => {
+  const title = utxo.resolution === "genesis" ? "genesis UTxO" : utxo.tags.length > 0 ? utxo.tags.join(", ") : key;
+  return {
+    id: utxoNodeId2(utxo),
+    kind: "utxo",
+    title,
+    subtitle: key,
+    chips: [
+      {
+        label: utxo.resolution,
+        tone: utxo.resolution === "unresolved" ? "danger" : utxo.resolution === "genesis" ? "warning" : "success"
+      },
+      ...utxo.tags.map((tag) => ({ label: tag, tone: "neutral" }))
+    ],
+    sections: [
+      section("owner", "Owner", [
+        field(
+          "address",
+          "Address",
+          addressName(utxo.address, trace),
+          true,
+          void 0,
+          utxo.address
+        )
+      ]),
+      section(
+        "assets",
+        "Assets",
+        Object.entries(utxo.assets).sort(([left], [right]) => assetSort(left, right)).map(
+          ([unit, amount]) => field(
+            `asset:${unit}`,
+            assetName(unit, trace),
+            amount,
+            false,
+            void 0,
+            void 0,
+            unit
+          )
+        )
+      ),
+      section("state", "State", [
+        ...utxo.datum ? [field("datum", "Datum", "inline datum")] : [],
+        ...utxo.datumHash ? [
+          field(
+            "datumHash",
+            "Datum hash",
+            shortHash(utxo.datumHash),
+            true,
+            void 0,
+            utxo.datumHash
+          )
+        ] : [],
+        ...utxo.scriptRef ? [
+          field(
+            "scriptRef",
+            "Script ref",
+            `${utxo.scriptRef.type}${utxo.scriptRef.hash ? ` ${shortHash(utxo.scriptRef.hash)}` : ""}`,
+            false,
+            void 0,
+            utxo.scriptRef.hash ? `${utxo.scriptRef.type} ${utxo.scriptRef.hash}` : utxo.scriptRef.type
+          )
+        ] : [],
+        ...utxo.unresolvedReason ? [
+          field(
+            "unresolved",
+            "Unresolved",
+            utxo.unresolvedReason,
+            false,
+            "danger"
+          )
+        ] : []
+      ])
+    ],
+    ports: [
+      port(utxoPortId(key, "in"), utxoNodeId2(utxo), "left", "in"),
+      port(utxoPortId(key, "out"), utxoNodeId2(utxo), "right", "out")
+    ],
+    ...utxo.resolution === "unresolved" ? { severity: "error" } : {},
+    rawRef: {
+      type: "utxo",
+      outRef: { txHash: utxo.txHash, outputIndex: utxo.outputIndex }
+    }
+  };
+};
+var assetPolicyNode = (policyId, assets, trace) => ({
+  id: assetPolicyNodeId(policyId),
+  kind: "asset",
+  title: `policy ${shortHash(policyId, 6)}`,
+  sections: [
+    section(
+      "assets",
+      "Assets",
+      Object.entries(assets).sort(([left], [right]) => assetSort(left, right)).map(
+        ([unit]) => field(
+          `asset:${unit}`,
+          "Asset",
+          assetName(unit, trace),
+          false,
+          void 0,
+          unit
+        )
+      )
+    )
+  ],
+  ports: [
+    port(
+      assetPolicyPortId(policyId),
+      assetPolicyNodeId(policyId),
+      "left",
+      "asset"
+    )
+  ],
+  chips: [{ label: shortHash(policyId, 6), tone: "accent" }],
+  rawRef: { type: "assetPolicy", policyId }
+});
+var mergeAssetPolicyNode = (existing, next) => {
+  if (!existing) return next;
+  const rows = /* @__PURE__ */ new Map();
+  for (const node of [existing, next]) {
+    const assetRows = node.sections.find(
+      (section2) => section2.id === "assets"
+    )?.rows;
+    for (const row of assetRows ?? []) {
+      rows.set(row.id, row);
+    }
+  }
+  return {
+    ...existing,
+    sections: [
+      section(
+        "assets",
+        "Assets",
+        [...rows.values()].sort(
+          (left, right) => left.id.localeCompare(right.id)
+        )
+      )
+    ]
+  };
+};
+var withdrawalNode = (rewardAddress, trace) => ({
+  id: withdrawalNodeId(rewardAddress),
+  kind: "withdrawal",
+  title: "withdrawal",
+  subtitle: addressName(rewardAddress, trace),
+  sections: [
+    section("reward", "Reward address", [
+      field(
+        "address",
+        "Address",
+        addressName(rewardAddress, trace),
+        true,
+        void 0,
+        rewardAddress
+      )
+    ])
+  ],
+  ports: [
+    port(
+      withdrawalPortId(rewardAddress),
+      withdrawalNodeId(rewardAddress),
+      "right",
+      "withdraw"
+    )
+  ],
+  chips: [],
+  rawRef: { type: "withdrawal", rewardAddress }
+});
+var certificateNode = (txHash, index, kindName) => ({
+  id: certificateNodeId(txHash, index),
+  kind: "certificate",
+  title: kindName,
+  subtitle: `certificate #${index}`,
+  sections: [
+    section("certificate", "Certificate", [field("kind", "Kind", kindName)])
+  ],
+  ports: [
+    port(
+      certificatePortId(txHash, index),
+      certificateNodeId(txHash, index),
+      "left",
+      "cert"
+    )
+  ],
+  chips: [],
+  rawRef: { type: "certificate", txHash, index }
+});
+var signerNode = (keyHash) => ({
+  id: signerNodeId(keyHash),
+  kind: "signer",
+  title: "signer",
+  subtitle: shortHash(keyHash),
+  sections: [
+    section("signer", "Signer", [
+      field(
+        "keyHash",
+        "Key hash",
+        shortHash(keyHash),
+        true,
+        void 0,
+        keyHash
+      )
+    ])
+  ],
+  ports: [port(signerPortId(keyHash), signerNodeId(keyHash), "right", "sign")],
+  chips: [],
+  rawRef: { type: "signer", keyHash }
+});
+var collateralReturnNode = (transaction) => ({
+  id: collateralReturnNodeId(transaction.hash),
+  kind: "collateralReturn",
+  title: "collateral return",
+  subtitle: shortHash(transaction.hash),
+  sections: [
+    section("assets", "Assets", [
+      ...Object.entries(transaction.collateralReturn?.assets ?? {}).sort(([left], [right]) => assetSort(left, right)).map(
+        ([unit, amount]) => field(
+          `asset:${unit}`,
+          unit,
+          amount,
+          false,
+          void 0,
+          void 0,
+          unit
+        )
+      )
+    ])
+  ],
+  ports: [
+    port(
+      collateralReturnPortId(transaction.hash),
+      collateralReturnNodeId(transaction.hash),
+      "left",
+      "collateral return"
+    )
+  ],
+  chips: [],
+  rawRef: { type: "collateralReturn", txHash: transaction.hash }
+});
+var ensureUtxoPlaceholder = (trace, nodes, outRef) => {
+  const id = utxoNodeId2(outRef);
+  if (nodes.has(id)) return;
+  const key = outRefKey(outRef);
+  nodes.set(
+    id,
+    utxoNode(
+      key,
+      {
+        ...outRef,
+        address: "unresolved",
+        assets: {},
+        resolution: "unresolved",
+        unresolvedReason: "missing-from-trace",
+        tags: []
+      },
+      trace
+    )
+  );
+};
+var transactionPorts = (transaction) => [
+  ...transaction.inputs.map(
+    (_input, index) => port(
+      transactionPortId(transaction.hash, "spend", index),
+      transactionNodeId(transaction.hash),
+      "left",
+      `spend #${index}`,
+      "spend"
+    )
+  ),
+  ...transaction.referenceInputs.map(
+    (_input, index) => port(
+      transactionPortId(transaction.hash, "read", index),
+      transactionNodeId(transaction.hash),
+      "left",
+      `read #${index}`,
+      "read"
+    )
+  ),
+  ...transaction.collateralInputs.map(
+    (_input, index) => port(
+      transactionPortId(transaction.hash, "collateral", index),
+      transactionNodeId(transaction.hash),
+      "left",
+      `collateral #${index}`,
+      "collateral"
+    )
+  ),
+  ...transaction.outputs.map(
+    (_output, index) => port(
+      transactionPortId(transaction.hash, "produce", index),
+      transactionNodeId(transaction.hash),
+      "right",
+      `output #${index}`,
+      "produce"
+    )
+  ),
+  ...sortedPolicyIds(transaction.mintedAssets).map((policyId) => {
+    const index = sortedPolicyIds(transaction.mint).indexOf(policyId);
+    return port(
+      transactionPortId(transaction.hash, "mint", index),
+      transactionNodeId(transaction.hash),
+      "bottom",
+      `mint #${index}`,
+      "mint"
+    );
+  }),
+  ...sortedPolicyIds(transaction.burnedAssets).map((policyId) => {
+    const index = sortedPolicyIds(transaction.mint).indexOf(policyId);
+    return port(
+      transactionPortId(transaction.hash, "burn", index),
+      transactionNodeId(transaction.hash),
+      "bottom",
+      `burn #${index}`,
+      "burn"
+    );
+  }),
+  ...transaction.withdrawals.map(
+    (_withdrawal, index) => port(
+      transactionPortId(transaction.hash, "withdraw", index),
+      transactionNodeId(transaction.hash),
+      "left",
+      `withdraw #${index}`,
+      "withdraw"
+    )
+  ),
+  ...transaction.certificates.map(
+    (certificate) => port(
+      transactionPortId(transaction.hash, "certify", certificate.index),
+      transactionNodeId(transaction.hash),
+      "right",
+      `cert #${certificate.index}`,
+      "certify"
+    )
+  ),
+  ...transaction.requiredSigners.map(
+    (_signer, index) => port(
+      transactionPortId(transaction.hash, "sign", index),
+      transactionNodeId(transaction.hash),
+      "left",
+      `signer #${index}`,
+      "sign"
+    )
+  ),
+  ...transaction.collateralReturn ? [
+    port(
+      transactionPortId(transaction.hash, "collateralReturn", 0),
+      transactionNodeId(transaction.hash),
+      "right",
+      "collateral return",
+      "collateralReturn"
+    )
+  ] : []
+];
+var redeemerKeyFor = (transaction, tag, index, mappedRedeemers) => {
+  const redeemer = transaction.redeemers.find(
+    (candidate) => candidate.tag === tag && candidate.index === String(index)
+  );
+  if (!redeemer) return void 0;
+  mappedRedeemers?.add(redeemerMapKey(transaction.hash, redeemer));
+  return {
+    tag: redeemer.tag,
+    index: redeemer.index,
+    redeemerListIndex: redeemer.redeemerListIndex
+  };
+};
+var applyAction = (trace, edge, describers) => {
+  const context = redeemerContext(trace, edge);
+  if (!context) return edge;
+  for (const describer of describers) {
+    const action = describer(context);
+    if (action) {
+      return { ...edge, action, label: action.label };
+    }
+  }
+  const fallback = genericAction(context.redeemer);
+  return {
+    ...edge,
+    action: fallback,
+    label: fallback.label
+  };
+};
+var redeemerContext = (trace, edge) => {
+  if (!edge.redeemerKey) return void 0;
+  const transaction = trace.transactions.find(
+    (candidate) => candidate.hash === edge.targetRef.txHash
+  );
+  const redeemer = transaction?.redeemers.find(
+    (candidate) => candidate.tag === edge.redeemerKey?.tag && candidate.index === edge.redeemerKey.index && candidate.redeemerListIndex === edge.redeemerKey.redeemerListIndex
+  );
+  return transaction && redeemer ? {
+    trace,
+    transaction,
+    redeemer,
+    target: edge.targetRef,
+    edge
+  } : void 0;
+};
+var genericAction = (redeemer) => ({
+  label: `${redeemer.tag} #${redeemer.index}`,
+  source: "generic",
+  confidence: "fallback"
+});
+var matchesRedeemer = (selector, { transaction, redeemer, target }) => redeemer.tag === selector.tag && redeemer.index === String(selector.index) && (!selector.txHash || transaction.hash === selector.txHash) && (!selector.target || selector.target(target));
+var constructorOf = (data) => {
+  try {
+    const alternative = CML.PlutusData.from_cbor_hex(data).as_constr_plutus_data()?.alternative();
+    if (alternative === void 0) return void 0;
+    const value = Number(alternative);
+    return Number.isSafeInteger(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var visualDiagnostic = (warning, index) => ({
+  id: `diagnostic:${index}:${warning.code}`,
+  severity: warning.code.includes("failed") ? "error" : "warning",
+  code: warning.code,
+  message: warning.message,
+  ...warning.txHash ? { txHash: warning.txHash } : {},
+  ...warning.outRef ? { outRef: warning.outRef } : {}
+});
+var unmappedRedeemerDiagnostics = (trace, mappedRedeemers) => trace.transactions.flatMap(
+  (transaction) => transaction.redeemers.filter(
+    (redeemer) => !mappedRedeemers.has(redeemerMapKey(transaction.hash, redeemer))
+  ).map((redeemer) => ({
+    id: `diagnostic:${transaction.hash}:unmapped-redeemer:${redeemer.tag}:${redeemer.index}`,
+    severity: "warning",
+    code: "unmapped-redeemer",
+    message: `Redeemer ${redeemer.tag} #${redeemer.index} in transaction ${transaction.hash} has no matching semantic edge`,
+    txHash: transaction.hash,
+    redeemerKey: {
+      tag: redeemer.tag,
+      index: redeemer.index,
+      redeemerListIndex: redeemer.redeemerListIndex
+    }
+  }))
+);
+var redeemerMapKey = (txHash, redeemer) => `${txHash}\0${redeemer.tag}\0${redeemer.index}\0${redeemer.redeemerListIndex}`;
+var assetsByPolicy = (assets) => {
+  const result = {};
+  for (const [unit, amount] of Object.entries(assets)) {
+    const policyId = policyIdOfUnit(unit);
+    result[policyId] = {
+      ...result[policyId] ?? {},
+      [unit]: amount
+    };
+  }
+  return result;
+};
+var sortedPolicyIds = (assets) => [...new Set(Object.keys(assets).map(policyIdOfUnit))].sort();
+var policyIdOfUnit = (unit) => unit === "lovelace" ? "lovelace" : unit.slice(0, 56);
+var section = (id, title, rows) => ({
+  id,
+  title,
+  rows: [...rows],
+  collapsed: rows.length === 0
+});
+var field = (id, label, value, mono = false, tone, rawValue, rawLabel) => ({
+  id,
+  label,
+  ...rawLabel ? { rawLabel } : {},
+  value,
+  ...rawValue ? { rawValue } : {},
+  ...mono ? { mono } : {},
+  ...tone ? { tone } : {}
+});
+var port = (id, nodeId, side, label, edgeKind) => ({
+  id,
+  nodeId,
+  side,
+  label,
+  ...edgeKind ? { edgeKind } : {}
+});
+var statusTone = (status) => {
+  switch (status) {
+    case "submitted":
+    case "confirmed":
+      return "success";
+    case "failed":
+      return "danger";
+    case "built":
+    case "signed":
+      return "info";
+  }
+};
+var assetSort = (left, right) => {
+  if (left === "lovelace") return -1;
+  if (right === "lovelace") return 1;
+  return left.localeCompare(right);
+};
+var transactionNodeId = (txHash) => `tx:${txHash}`;
+var utxoNodeId2 = (outRef) => `utxo:${outRefKey(outRef)}`;
+var assetPolicyNodeId = (policyId) => `asset-policy:${policyId}`;
+var signerNodeId = (keyHash) => `signer:${keyHash}`;
+var withdrawalNodeId = (rewardAddress) => `withdrawal:${rewardAddress}`;
+var certificateNodeId = (txHash, index) => `certificate:${txHash}#${index}`;
+var collateralReturnNodeId = (txHash) => `collateral-return:${txHash}`;
+var transactionPortId = (txHash, kind, index) => `tx:${txHash}:port:${kind}:${index}`;
+var utxoPortId = (key, direction) => `utxo:${key}:port:${direction}`;
+var assetPolicyPortId = (policyId) => `asset-policy:${policyId}:port`;
+var signerPortId = (keyHash) => `signer:${keyHash}:port`;
+var withdrawalPortId = (rewardAddress) => `withdrawal:${rewardAddress}:port`;
+var certificatePortId = (txHash, index) => `certificate:${txHash}#${index}:port`;
+var collateralReturnPortId = (txHash) => `collateral-return:${txHash}:port`;
+var defaultLegend = {
+  nodes: [
+    { kind: "transaction", label: "Transaction" },
+    { kind: "utxo", label: "UTxO" },
+    { kind: "asset", label: "Asset policy" },
+    { kind: "diagnostic", label: "Diagnostic" }
+  ],
+  edges: [
+    { kind: "spend", label: "Spend input" },
+    { kind: "read", label: "Reference input" },
+    { kind: "collateral", label: "Collateral input" },
+    { kind: "produce", label: "Produced output" },
+    { kind: "mint", label: "Mint policy" },
+    { kind: "burn", label: "Burn policy" },
+    { kind: "withdraw", label: "Withdrawal" },
+    { kind: "certify", label: "Certificate" },
+    { kind: "sign", label: "Required signer" }
+  ]
+};
+
+// src/render/dot.ts
+var traceToDot = (trace, options = {}) => {
+  if (options.legacy) return traceToLegacyDot(trace, options);
+  const resolved = resolveVisualRendererOptions(options);
+  const graph = formatSemanticGraph(
+    buildSemanticRenderGraph(trace, {
+      redeemers: options.redeemers
+    }),
+    resolved
+  );
+  const semanticNodes = new Map(
+    graph.nodes.map((node) => [node.id, node])
+  );
+  const nodeIds = new Map(
+    graph.nodes.map((node, index) => [node.id, `n${index}`])
+  );
+  const lines = [
+    `digraph ${dotString(options.graphName ?? "lucid-evolution-tx-graph")} {`,
+    "  rankdir=LR;",
+    "  splines=ortho;",
+    "  nodesep=0.45;",
+    "  ranksep=0.75;",
+    '  graph [fontname="Inter, Arial", bgcolor="white", pad=0.2];',
+    '  node [fontname="Inter, Arial", fontsize=10, shape=plain, margin=0];',
+    '  edge [fontname="Inter, Arial", fontsize=9, arrowsize=0.7];'
+  ];
+  for (const node of graph.nodes) {
+    lines.push(
+      `  ${dotString(nodeIds.get(node.id))} [${semanticNodeAttributes(
+        node,
+        resolved
+      )}];`
+    );
+  }
+  for (const edge of graph.edges) {
+    const style = visualEdgeStyle(edge.kind);
+    const scriptFocus = resolved.view === "scriptInteraction" && isScriptInteractionEdge(edge, semanticNodes);
+    lines.push(
+      `  ${dotString(nodeIds.get(edge.from))} -> ${dotString(
+        nodeIds.get(edge.to)
+      )} [` + [
+        `label=${dotString(semanticEdgeLabel(trace, edge, resolved))}`,
+        `color=${dotString(style.color)}`,
+        `fontcolor=${dotString(style.color)}`,
+        `style=${dotString(style.style)}`,
+        `penwidth=${scriptFocus ? "2.8" : edge.kind === "spend" || edge.kind === "produce" ? "1.6" : "1.1"}`
+      ].join(", ") + "];"
+    );
+  }
+  lines.push("}");
+  return `${lines.join("\n")}
+`;
+};
+var semanticNodeAttributes = (node, options) => [
+  `label=<${semanticNodeLabel(node, options)}>`,
+  `tooltip=${dotString(nodeTooltip(node, options))}`
+].join(", ");
+var semanticNodeLabel = (node, options) => {
+  const palette = nodePalette(node);
+  const subtitle = semanticNodeSubtitle(node, options);
+  const chips = semanticChipLabels(node, options);
+  const sections = visibleSemanticSections(node, options);
+  return [
+    `<TABLE BORDER="1" CELLBORDER="0" CELLSPACING="0" CELLPADDING="5" COLOR="${palette.border}">`,
+    `<TR><TD COLSPAN="2" BGCOLOR="${palette.header}"><B>${htmlText(semanticNodeTitle(node, options))}</B>${subtitle ? `<BR/><FONT POINT-SIZE="9">${htmlText(subtitle)}</FONT>` : ""}</TD></TR>`,
+    ...chips.length > 0 ? [
+      `<TR><TD COLSPAN="2" BGCOLOR="${palette.chip}"><FONT POINT-SIZE="9">${htmlText(
+        chips.join(" | ")
+      )}</FONT></TD></TR>`
+    ] : [],
+    ...sections.flatMap((section2) => sectionRows(section2, node, options)),
+    "</TABLE>"
+  ].join("");
+};
+var sectionRows = (section2, node, options) => {
+  const rows = visibleSemanticRows(section2, node, options);
+  if (rows.length === 0) return [];
+  return [
+    `<TR><TD COLSPAN="2" ALIGN="LEFT" BGCOLOR="#f9fafb"><B>${htmlText(
+      section2.title
+    )}</B></TD></TR>`,
+    ...rows.map((row) => {
+      const value = semanticFieldValue(row, options);
+      const valueFace = row.mono ? ' FACE="monospace"' : "";
+      return `<TR><TD ALIGN="LEFT"><FONT POINT-SIZE="9">${htmlText(
+        semanticFieldLabel(row, options)
+      )}</FONT></TD><TD ALIGN="LEFT"><FONT${valueFace}>${htmlText(
+        value
+      )}</FONT></TD></TR>`;
+    })
+  ];
+};
+var nodeTooltip = (node, options) => [
+  semanticNodeTitle(node, options),
+  ...semanticNodeSubtitle(node, options) ? [semanticNodeSubtitle(node, options)] : [],
+  ...node.sections.flatMap(
+    (section2) => section2.rows.map(
+      (row) => `${section2.title}.${semanticFieldLabel(row, options)}: ${semanticFieldValue(
+        row,
+        options
+      )}`
+    )
+  )
+].join("\n");
+var nodePalette = (node) => {
+  if (node.severity === "error") {
+    return { header: "#fee2e2", chip: "#fef2f2", border: "#dc2626" };
+  }
+  if (isGenesisNode(node)) {
+    return { header: "#fef3c7", chip: "#fffbeb", border: "#d97706" };
+  }
+  if (node.rawRef.type === "diagnostic" && node.rawRef.code === "collapsed") {
+    return { header: "#f3f4f6", chip: "#f9fafb", border: "#6b7280" };
+  }
+  switch (node.kind) {
+    case "transaction":
+      return { header: "#eef2ff", chip: "#e0e7ff", border: "#6366f1" };
+    case "utxo":
+      return { header: "#ecfdf5", chip: "#d1fae5", border: "#10b981" };
+    case "asset":
+      return { header: "#f5f3ff", chip: "#ede9fe", border: "#7c3aed" };
+    case "signer":
+      return { header: "#f3f4f6", chip: "#f9fafb", border: "#6b7280" };
+    case "withdrawal":
+      return { header: "#ecfeff", chip: "#cffafe", border: "#0891b2" };
+    case "certificate":
+      return { header: "#eef2ff", chip: "#e0e7ff", border: "#4f46e5" };
+    case "collateralReturn":
+      return { header: "#fffbeb", chip: "#fef3c7", border: "#f59e0b" };
+    case "diagnostic":
+      return { header: "#fef2f2", chip: "#fee2e2", border: "#dc2626" };
+  }
+};
+var htmlText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/\\n/g, "<BR/>").replace(/\n/g, "<BR/>");
+var traceToLegacyDot = (trace, options = {}) => {
+  const graph = buildRenderGraph(trace);
+  const lines = [
+    `digraph ${dotString(options.graphName ?? "lucid-evolution-tx-graph")} {`,
+    "  rankdir=LR;",
+    '  graph [fontname="Inter, Arial", bgcolor="white"];',
+    '  node [fontname="Inter, Arial", fontsize=10, margin="0.08,0.06"];',
+    '  edge [fontname="Inter, Arial", fontsize=9, arrowsize=0.7];'
+  ];
+  for (const node of graph.nodes) {
+    lines.push(`  ${dotString(node.id)} [${legacyNodeAttributes(node)}];`);
+  }
+  for (const edge of graph.edges) {
+    const style = edgeStyle(edge.kind);
+    lines.push(
+      `  ${dotString(edge.from)} -> ${dotString(edge.to)} [` + [
+        `label=${dotString(style.label)}`,
+        `color=${dotString(style.color)}`,
+        `fontcolor=${dotString(style.color)}`,
+        `style=${dotString(style.style)}`
+      ].join(", ") + "];"
+    );
+  }
+  lines.push("}");
+  return `${lines.join("\n")}
+`;
+};
+var legacyNodeAttributes = (node) => {
+  const attrs = [
+    `label=${dotString(node.label)}`,
+    `shape=${dotString(legacyNodeShape(node))}`,
+    `style=${dotString(legacyNodeStyle(node))}`,
+    `fillcolor=${dotString(legacyNodeFill(node))}`,
+    `color=${dotString(legacyNodeColor(node))}`
+  ];
+  return attrs.join(", ");
+};
+var legacyNodeShape = (node) => {
+  switch (node.kind) {
+    case "transaction":
+      return "box";
+    case "utxo":
+      return "box";
+    case "asset":
+      return "component";
+    case "signer":
+      return "octagon";
+    case "withdrawal":
+    case "certificate":
+    case "collateralReturn":
+    case "external":
+      return "note";
+  }
+};
+var legacyNodeStyle = (node) => node.kind === "utxo" ? "rounded,filled" : "filled";
+var legacyNodeFill = (node) => {
+  if (node.unresolved) return "#fee2e2";
+  if (node.genesis) return "#fef3c7";
+  switch (node.kind) {
+    case "transaction":
+      return "#eef2ff";
+    case "utxo":
+      return "#ecfdf5";
+    case "asset":
+      return "#f5f3ff";
+    case "signer":
+      return "#f3f4f6";
+    case "withdrawal":
+      return "#ecfeff";
+    case "certificate":
+      return "#eef2ff";
+    case "collateralReturn":
+      return "#fffbeb";
+    case "external":
+      return "#f9fafb";
+  }
+};
+var legacyNodeColor = (node) => node.unresolved ? "#dc2626" : node.genesis ? "#d97706" : "#9ca3af";
+var dotString = (value) => JSON.stringify(value.replace(/\\n/g, "\n"));
+
+// src/render/measure.ts
+var MARGIN = 40;
+var TITLE_HEIGHT = 74;
+var LEGEND_HEIGHT = 132;
+var MIN_CANVAS_WIDTH = 940;
+var NODE_GAP_Y = 34;
+var RANK_GAP_X = 170;
+var LABEL_GAP = 8;
+var measureNode = (node, options) => {
+  const width = nodeWidth(node);
+  if (node.kind === "transaction") {
+    return { width, height: measureTransactionNode(node, options) };
+  }
+  const sections = visibleSemanticSections(node, options);
+  const rowCount = sections.reduce(
+    (sum, section2) => sum + visibleSemanticRows(section2, node, options).length,
+    0
+  );
+  const populatedSections = sections.filter(
+    (section2) => visibleSemanticRows(section2, node, options).length > 0
+  ).length;
+  const chips = semanticChipLabels(node, options);
+  const chipRows = estimateChipRows(chips, width - 28);
+  return {
+    width,
+    height: 58 + chipRows * 24 + populatedSections * 24 + rowCount * 23 + 22
+  };
+};
+var measureLabel = (label) => ({
+  width: Math.min(260, Math.max(54, label.length * 6.4 + 18)),
+  height: 22
+});
+var visibleEdgeLabel = (trace, edge, options) => {
+  if (edge.action || edge.redeemerKey) {
+    return edge.action?.label ?? semanticEdgeLabel(trace, edge, options);
+  }
+  if (edge.kind === "diagnostic")
+    return semanticEdgeLabel(trace, edge, options);
+  if (edge.kind === "mint" || edge.kind === "burn") {
+    return options.mode === "overview" ? void 0 : edge.label;
+  }
+  if (edge.kind === "withdraw" || edge.kind === "certify") return edge.label;
+  if (edge.kind === "collateral" || edge.kind === "collateralReturn") {
+    return options.mode === "debug" ? edge.label : void 0;
+  }
+  return void 0;
+};
+var nodeWidth = (node) => {
+  switch (node.kind) {
+    case "transaction":
+      return 330;
+    case "utxo":
+      return 306;
+    case "diagnostic":
+      return 286;
+    case "asset":
+      return 270;
+    case "withdrawal":
+    case "certificate":
+    case "collateralReturn":
+      return 270;
+    case "signer":
+      return 240;
+  }
+};
+var metricRowCount = (node, options) => {
+  const metricRows = visibleSemanticSections(node, options).filter(
+    (section2) => ["inputs", "assets", "authority", "redeemers"].includes(section2.id)
+  ).flatMap((section2) => visibleSemanticRows(section2, node, options)).filter((row) => row.value !== "0").length;
+  return metricRows === 0 ? 0 : Math.ceil(metricRows / 4);
+};
+var measureTransactionNode = (node, options) => {
+  const metricRows = metricRowCount(node, options);
+  const facts = rowsForSection(node, options, "facts").slice(0, 4);
+  const redeemers = rowsForSection(node, options, "redeemers").slice(0, 1);
+  const detailRows = facts.length + redeemers.length;
+  const metricsHeight = metricRows === 0 ? 0 : metricRows * 34 + 8;
+  const detailsHeight = detailRows === 0 ? 0 : 27 + detailRows * 21;
+  return 64 + metricsHeight + detailsHeight + 12;
+};
+var rowsForSection = (node, options, sectionId) => visibleSemanticSections(node, options).filter((section2) => section2.id === sectionId).flatMap((section2) => visibleSemanticRows(section2, node, options)).filter((row) => row.value !== "0");
+var estimateChipRows = (chips, availableWidth) => {
+  if (chips.length === 0) return 0;
+  let rows = 1;
+  let cursor = 0;
+  for (const chip of chips) {
+    const width = Math.max(42, Math.min(18, chip.length) * 6 + 18) + 6;
+    if (cursor > 0 && cursor + width > availableWidth) {
+      rows += 1;
+      cursor = 0;
+    }
+    cursor += width;
+  }
+  return rows;
+};
+
+// src/render/layout.ts
+var layoutGraph = (trace, graph, options) => {
+  const sizes = new Map(
+    graph.nodes.map((node) => [node.id, measureNode(node, options)])
+  );
+  const ranks = rankNodes(trace, graph);
+  const rankedNodes = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const rank = ranks.get(node.id) ?? 0;
+    rankedNodes.set(rank, [...rankedNodes.get(rank) ?? [], node]);
+  }
+  const orderedRanks = [...rankedNodes.keys()].sort(
+    (left, right) => left - right
+  );
+  const rankWidths = new Map(
+    orderedRanks.map((rank) => [
+      rank,
+      Math.max(
+        ...rankedNodes.get(rank).map((node) => sizes.get(node.id).width)
+      )
+    ])
+  );
+  const rankHeights = new Map(
+    orderedRanks.map((rank) => [
+      rank,
+      rankedNodes.get(rank).reduce((sum, node) => sum + sizes.get(node.id).height, 0) + Math.max(0, rankedNodes.get(rank).length - 1) * NODE_GAP_Y
+    ])
+  );
+  const maxRankHeight = Math.max(0, ...rankHeights.values());
+  let x = MARGIN;
+  const rankX = /* @__PURE__ */ new Map();
+  for (const rank of orderedRanks) {
+    rankX.set(rank, x);
+    x += (rankWidths.get(rank) ?? 0) + RANK_GAP_X;
+  }
+  const positioned = /* @__PURE__ */ new Map();
+  for (const rank of orderedRanks) {
+    const nodes = [...rankedNodes.get(rank)].sort(
+      (left, right) => nodeSortKey(left, graph).localeCompare(nodeSortKey(right, graph))
+    );
+    let y = MARGIN + TITLE_HEIGHT + 32 + Math.max(0, (maxRankHeight - (rankHeights.get(rank) ?? 0)) / 2);
+    for (const node of nodes) {
+      const size = sizes.get(node.id);
+      positioned.set(node.id, {
+        node,
+        ...size,
+        x: rankX.get(rank) + ((rankWidths.get(rank) ?? size.width) - size.width) / 2,
+        y
+      });
+      y += size.height + NODE_GAP_Y;
+    }
+  }
+  const ports = portOffsets(graph, positioned);
+  const provisional = {
+    nodes: positioned,
+    portOffsets: ports,
+    edgeLabels: /* @__PURE__ */ new Map(),
+    width: MIN_CANVAS_WIDTH,
+    height: 260,
+    offsetX: 0,
+    offsetY: 0
+  };
+  const edgeLabels = placeEdgeLabels(trace, graph, options, provisional);
+  const boxes = [
+    ...[...positioned.values()].map(nodeBox),
+    ...edgeLabels.values()
+  ];
+  const maxX = Math.max(0, ...boxes.map((box) => box.x + box.width));
+  const maxY = Math.max(0, ...boxes.map((box) => box.y + box.height));
+  return {
+    nodes: positioned,
+    portOffsets: ports,
+    edgeLabels,
+    width: Math.max(MIN_CANVAS_WIDTH, Math.ceil(maxX + MARGIN)),
+    height: Math.ceil(maxY + MARGIN + LEGEND_HEIGHT),
+    offsetX: 0,
+    offsetY: 0
+  };
+};
+var nodeBox = (node) => ({
+  x: node.x,
+  y: node.y,
+  width: node.width,
+  height: node.height
+});
+var edgeAnchors = (edge, graph) => {
+  const from = graph.nodes.get(edge.from);
+  const to = graph.nodes.get(edge.to);
+  if (!from || !to) return void 0;
+  return {
+    start: anchor(edge, "from", from, to, graph),
+    end: anchor(edge, "to", to, from, graph)
+  };
+};
+var edgePath = (edge, graph) => {
+  const anchors = edgeAnchors(edge, graph);
+  if (!anchors) return "";
+  const { start, end } = anchors;
+  const dx = end.x - start.x;
+  const dy = end.y - start.y;
+  if (Math.abs(dx) < 80) {
+    const curve = Math.max(50, Math.abs(dy) / 2);
+    const direction = dy >= 0 ? 1 : -1;
+    return `M ${start.x} ${start.y} C ${start.x} ${start.y + curve * direction}, ${end.x} ${end.y - curve * direction}, ${end.x} ${end.y}`;
+  }
+  const midX = start.x + dx / 2;
+  return `M ${start.x} ${start.y} L ${midX} ${start.y} L ${midX} ${end.y} L ${end.x} ${end.y}`;
+};
+var edgeLabelPoint = (edge, graph) => {
+  const anchors = edgeAnchors(edge, graph);
+  if (!anchors) return { x: 0, y: 0 };
+  const { start, end } = anchors;
+  return {
+    x: (start.x + end.x) / 2,
+    y: (start.y + end.y) / 2
+  };
+};
+var rankNodes = (trace, graph) => {
+  const txIndex = new Map(
+    trace.transactions.map(
+      (transaction, index) => [transaction.hash, index]
+    )
+  );
+  const edgeTxIndices = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    const txHash = edge.targetRef.txHash;
+    if (!txHash) continue;
+    const index = txIndex.get(txHash);
+    if (index === void 0) continue;
+    for (const nodeId of [edge.from, edge.to]) {
+      edgeTxIndices.set(nodeId, [...edgeTxIndices.get(nodeId) ?? [], index]);
+    }
+  }
+  const ranks = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const attachedTxs = edgeTxIndices.get(node.id) ?? [0];
+    const attachedTx = Math.min(...attachedTxs);
+    const latestAttachedTx = Math.max(...attachedTxs);
+    switch (node.rawRef.type) {
+      case "transaction": {
+        ranks.set(
+          node.id,
+          (txIndex.get(node.rawRef.txHash) ?? attachedTx) * 2 + 1
+        );
+        break;
+      }
+      case "utxo": {
+        const producer = txIndex.get(node.rawRef.outRef.txHash);
+        ranks.set(
+          node.id,
+          producer === void 0 ? attachedTx * 2 : producer * 2 + 2
+        );
+        break;
+      }
+      case "assetPolicy":
+        ranks.set(node.id, latestAttachedTx * 2 + 2);
+        break;
+      case "certificate":
+      case "collateralReturn":
+        ranks.set(node.id, attachedTx * 2 + 2);
+        break;
+      case "signer":
+      case "withdrawal":
+        ranks.set(node.id, attachedTx * 2);
+        break;
+      case "diagnostic":
+        ranks.set(node.id, attachedTx * 2 + 1);
+        break;
+    }
+  }
+  return ranks;
+};
+var nodeSortKey = (node, graph) => {
+  const attached = graph.edges.filter((edge) => edge.from === node.id || edge.to === node.id).map((edge) => targetRefSortIndex(edge.targetRef));
+  const attachedIndex = attached.length === 0 ? 0 : Math.min(...attached);
+  return [
+    String(kindPriority(node)).padStart(2, "0"),
+    String(attachedIndex).padStart(4, "0"),
+    rawRefSortKey(node),
+    node.id
+  ].join(":");
+};
+var targetRefSortIndex = (targetRef) => {
+  switch (targetRef.type) {
+    case "input":
+    case "output":
+    case "withdrawal":
+    case "certificate":
+      return targetRef.index;
+    case "assetPolicy":
+      return targetRef.policyIndex;
+    case "signer":
+    case "collateralReturn":
+      return 0;
+    case "diagnostic":
+      return targetRef.count ?? 0;
+  }
+};
+var kindPriority = (node) => {
+  switch (node.kind) {
+    case "diagnostic":
+      return 0;
+    case "withdrawal":
+      return 1;
+    case "signer":
+      return 2;
+    case "transaction":
+      return 3;
+    case "utxo":
+      return 4;
+    case "asset":
+      return 5;
+    case "certificate":
+      return 6;
+    case "collateralReturn":
+      return 7;
+  }
+};
+var rawRefSortKey = (node) => {
+  switch (node.rawRef.type) {
+    case "utxo":
+      return outRefKey(node.rawRef.outRef);
+    case "transaction":
+      return node.rawRef.txHash;
+    case "assetPolicy":
+      return node.rawRef.policyId;
+    case "signer":
+      return node.rawRef.keyHash;
+    case "withdrawal":
+      return node.rawRef.rewardAddress;
+    case "certificate":
+      return `${node.rawRef.txHash}#${node.rawRef.index}`;
+    case "collateralReturn":
+      return node.rawRef.txHash;
+    case "diagnostic":
+      return node.rawRef.code;
+  }
+};
+var placeEdgeLabels = (trace, formatted, options, graph) => {
+  const nodeBoxes = [...graph.nodes.values()].map(
+    (node) => inflate(nodeBox(node), LABEL_GAP)
+  );
+  const placed = [];
+  const result = /* @__PURE__ */ new Map();
+  for (const edge of formatted.edges) {
+    const text = visibleEdgeLabel(trace, edge, options);
+    if (!text) continue;
+    const labelText = fit(text, options.mode === "debug" ? 42 : 28);
+    const size = measureLabel(labelText);
+    const origin = edgeLabelPoint(edge, graph);
+    const candidates = labelCandidates(origin, size);
+    const box = candidates.find(
+      (candidate) => !nodeBoxes.some((node) => intersects(candidate, node)) && !placed.some(
+        (label2) => intersects(candidate, inflate(label2, LABEL_GAP))
+      )
+    );
+    if (!box) continue;
+    const label = { ...box, edgeId: edge.id, text: labelText };
+    placed.push(label);
+    result.set(edge.id, label);
+  }
+  return result;
+};
+var labelCandidates = (origin, size) => {
+  const x = origin.x - size.width / 2;
+  const y = origin.y - size.height / 2;
+  const offsets = [
+    [0, -28],
+    [0, 28],
+    [0, -56],
+    [0, 56],
+    [-44, -28],
+    [44, -28],
+    [-44, 28],
+    [44, 28],
+    [0, -84],
+    [0, 84]
+  ];
+  return offsets.map(([dx, dy]) => ({
+    x: x + dx,
+    y: y + dy,
+    width: size.width,
+    height: size.height
+  }));
+};
+var portOffsets = (graph, nodes) => {
+  const edgeCountByPort = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    for (const portId of [edge.fromPort, edge.toPort]) {
+      if (portId)
+        edgeCountByPort.set(portId, (edgeCountByPort.get(portId) ?? 0) + 1);
+    }
+  }
+  const offsets = /* @__PURE__ */ new Map();
+  for (const layoutNode of nodes.values()) {
+    const ports = layoutNode.node.ports.filter((port2) => edgeCountByPort.has(port2.id)).sort(
+      (left, right) => portSortKey(left, layoutNode.node).localeCompare(
+        portSortKey(right, layoutNode.node)
+      )
+    );
+    const bySide = groupPortsBySide(ports);
+    for (const sidePorts of bySide.values()) {
+      sidePorts.forEach((port2, index) => {
+        if (port2.side === "top" || port2.side === "bottom") {
+          offsets.set(
+            port2.id,
+            (index + 1) * layoutNode.width / (sidePorts.length + 1)
+          );
+        } else {
+          offsets.set(
+            port2.id,
+            60 + (index + 1) * Math.max(24, layoutNode.height - 92) / (sidePorts.length + 1)
+          );
+        }
+      });
+    }
+  }
+  return offsets;
+};
+var groupPortsBySide = (ports) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const port2 of ports) {
+    groups.set(port2.side, [...groups.get(port2.side) ?? [], port2]);
+  }
+  return groups;
+};
+var portSortKey = (port2, node) => [
+  String(portSidePriority(port2.side)).padStart(2, "0"),
+  String(edgeKindPriority(port2.edgeKind)).padStart(2, "0"),
+  port2.id.replace(
+    /:(\d+)(?::|$)/g,
+    (_match, index) => `:${index.padStart(4, "0")}:`
+  ),
+  node.id
+].join(":");
+var portSidePriority = (side) => {
+  switch (side) {
+    case "left":
+      return 0;
+    case "right":
+      return 1;
+    case "top":
+      return 2;
+    case "bottom":
+      return 3;
+    default:
+      return 4;
+  }
+};
+var edgeKindPriority = (kind) => {
+  switch (kind) {
+    case "spend":
+      return 0;
+    case "read":
+      return 1;
+    case "collateral":
+      return 2;
+    case "produce":
+      return 3;
+    case "mint":
+      return 4;
+    case "withdraw":
+      return 5;
+    case "certify":
+      return 6;
+    case "sign":
+      return 7;
+    default:
+      return 8;
+  }
+};
+var anchor = (edge, endpoint, node, other, graph) => {
+  const portId = endpoint === "from" ? edge.fromPort : edge.toPort;
+  const port2 = portId ? node.node.ports.find((candidate) => candidate.id === portId) : void 0;
+  const offset = portId ? graph.portOffsets.get(portId) : void 0;
+  if (port2?.side === "top") {
+    return { x: node.x + (offset ?? node.width / 2), y: node.y };
+  }
+  if (port2?.side === "bottom") {
+    return { x: node.x + (offset ?? node.width / 2), y: node.y + node.height };
+  }
+  if (port2?.side === "left") {
+    return { x: node.x, y: node.y + (offset ?? node.height / 2) };
+  }
+  if (port2?.side === "right") {
+    return { x: node.x + node.width, y: node.y + (offset ?? node.height / 2) };
+  }
+  const nodeCenterX = node.x + node.width / 2;
+  const otherCenterX = other.x + other.width / 2;
+  return {
+    x: otherCenterX >= nodeCenterX ? node.x + node.width : node.x,
+    y: node.y + node.height / 2
+  };
+};
+var inflate = (box, padding) => ({
+  x: box.x - padding,
+  y: box.y - padding,
+  width: box.width + padding * 2,
+  height: box.height + padding * 2
+});
+var intersects = (left, right) => left.x < right.x + right.width && left.x + left.width > right.x && left.y < right.y + right.height && left.y + left.height > right.y;
+var fit = (value, maxChars) => value.length <= maxChars ? value : `${value.slice(0, maxChars - 3)}...`;
+
+// src/render/edge-renderer.ts
+var renderEdge = (trace, edge, index, graph, options, semanticNodes, semantic) => {
+  if (!graph.nodes.has(edge.from) || !graph.nodes.has(edge.to)) return "";
+  const path = edgePath(edge, graph);
+  const style = visualEdgeStyle(edge.kind);
+  const scriptFocus = options.view === "scriptInteraction" && isScriptInteractionEdge(edge, semanticNodes);
+  const label = graph.edgeLabels.get(edge.id);
+  return [
+    `<g data-txg-id="${opaqueId(semantic, edge.id)}" data-txg-type="edge" class="txg-edge txg-${edge.kind}">`,
+    `<title>${xmlText(semanticEdgeLabel(trace, edge, options))}</title>`,
+    `<path class="txg-edge-hit" d="${path}" fill="none" stroke="transparent" stroke-width="12" pointer-events="stroke"/>`,
+    `<path d="${path}" fill="none" stroke="${style.color}" stroke-width="${strokeWidth(edge, scriptFocus)}" marker-end="url(#txg-arrow)"${dashArray(style.style)}/>`,
+    label ? renderEdgeLabel(
+      label.x,
+      label.y,
+      label.width,
+      label.height,
+      label.text,
+      style.color
+    ) : "",
+    "</g>"
+  ].join("\n");
+};
+var renderEdgeLabel = (x, y, width, height, label, color) => [
+  `<rect class="txg-edge-label" x="${x}" y="${y}" width="${width}" height="${height}" rx="5" fill="#ffffff" stroke="#cbd5e1"/>`,
+  `<text x="${x + width / 2}" y="${y + 14}" text-anchor="middle" font-family="Inter, Arial" font-size="10" font-weight="700" fill="${color}">${xmlText(label)}</text>`
+].join("\n");
+var strokeWidth = (edge, scriptFocus) => {
+  if (scriptFocus) return "2.8";
+  if (edge.kind === "spend") return "2.2";
+  if (edge.kind === "produce") return "1.9";
+  if (edge.kind === "diagnostic") return "2";
+  return "1.35";
+};
+var dashArray = (style) => style === "solid" ? "" : style === "dotted" ? ' stroke-dasharray="2 4"' : ' stroke-dasharray="6 5"';
+var opaqueId = (graph, id) => {
+  const nodeIndex = graph.nodes.findIndex((node) => node.id === id);
+  if (nodeIndex >= 0) return `node:${nodeIndex}`;
+  const edgeIndex = graph.edges.findIndex((edge) => edge.id === id);
+  return edgeIndex >= 0 ? `edge:${edgeIndex}` : id;
+};
+var xmlText = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+// src/render/node-renderer.ts
+var renderNode = (layoutNode, graph, options, index, semantic) => {
+  switch (layoutNode.node.kind) {
+    case "transaction":
+      return renderTransactionNode(layoutNode, graph, options, index, semantic);
+    case "utxo":
+      return renderUtxoNode(layoutNode, graph, options, index, semantic);
+    default:
+      return renderGenericNode(layoutNode, graph, options, index, semantic);
+  }
+};
+var renderLegend = (graph, semantic) => {
+  const y = graph.height - LEGEND_HEIGHT + 34;
+  const itemWidth = 156;
+  const items = edgeLegendItems(semantic);
+  const perRow = Math.max(1, Math.floor((graph.width - 80) / itemWidth));
+  return [
+    `<g class="txg-legend">`,
+    `<text x="40" y="${y}" font-family="Inter, Arial" font-size="12" font-weight="700" fill="#111827">Legend</text>`,
+    ...items.map(([label, title], index) => {
+      const style = visualEdgeStyle(label);
+      const x = 40 + index % perRow * itemWidth;
+      const rowY = y + 24 + Math.floor(index / perRow) * 30;
+      return [
+        `<g>`,
+        `<title>${xmlText2(title)}</title>`,
+        `<line x1="${x}" y1="${rowY}" x2="${x + 30}" y2="${rowY}" stroke="${style.color}" stroke-width="2.2"${dashArray2(style.style)}/>`,
+        `<text x="${x + 38}" y="${rowY + 4}" font-family="Inter, Arial" font-size="11" fill="#374151">${label}</text>`,
+        `</g>`
+      ].join("\n");
+    }),
+    "</g>"
+  ].join("\n");
+};
+var edgeLegendItems = (semantic) => {
+  const present = new Set(semantic.edges.map((edge) => edge.kind));
+  const ordered = [
+    "spend",
+    "read",
+    "collateral",
+    "produce",
+    "mint",
+    "burn",
+    "withdraw",
+    "certify",
+    "sign",
+    "collateralReturn",
+    "diagnostic",
+    "summary"
+  ].filter((kind) => present.has(kind));
+  return (ordered.length > 0 ? ordered : ["spend", "produce"]).map((kind) => [
+    kind,
+    edgeLegendTitle(kind)
+  ]);
+};
+var edgeLegendTitle = (kind) => {
+  switch (kind) {
+    case "spend":
+      return "Consumes an input UTxO";
+    case "read":
+      return "Reads a reference input without consuming it";
+    case "collateral":
+      return "Uses collateral for script validation";
+    case "produce":
+      return "Creates an output UTxO";
+    case "mint":
+      return "Mints assets under a policy";
+    case "burn":
+      return "Burns assets under a policy";
+    case "withdraw":
+      return "Withdraws staking rewards";
+    case "certify":
+      return "Applies a certificate";
+    case "sign":
+      return "Requires a signer";
+    case "collateralReturn":
+      return "Returns collateral";
+    case "diagnostic":
+      return "Warning or error";
+    default:
+      return kind;
+  }
+};
+var dashArray2 = (style) => style === "solid" ? "" : style === "dotted" ? ' stroke-dasharray="2 4"' : ' stroke-dasharray="6 5"';
+var renderTransactionNode = (layoutNode, graph, options, index, semantic) => {
+  const { node, width, height } = layoutNode;
+  const x = layoutNode.x + graph.offsetX;
+  const y = layoutNode.y + graph.offsetY;
+  const palette = nodePalette2(node);
+  const title = fit2(semanticNodeTitle(node, options), 38);
+  const subtitle = semanticNodeSubtitle(node, options);
+  const status = node.chips[0]?.label ?? "tx";
+  const metrics = transactionMetrics(node, options);
+  const facts = sectionRows2(node, options, "facts").slice(0, 4);
+  const redeemers = sectionRows2(node, options, "redeemers").slice(0, 1);
+  let cursor = y + 64;
+  const lines = baseNodeOpen(
+    index,
+    node,
+    semantic,
+    options,
+    x,
+    y,
+    width,
+    height,
+    palette
+  );
+  lines.push(
+    `<rect x="${x}" y="${y}" width="${width}" height="54" rx="8" fill="${palette.header}"/>`,
+    `<text x="${x + 14}" y="${y + 21}" font-family="Inter, Arial" font-size="14" font-weight="700" fill="#0f172a">${xmlText2(title)}</text>`,
+    `<text x="${x + 14}" y="${y + 40}" font-family="ui-monospace, SFMono-Regular, monospace" font-size="10" fill="#475569">${xmlText2(fit2(subtitle ?? "", 36))}</text>`,
+    `<rect x="${x + width - 88}" y="${y + 13}" width="72" height="24" rx="12" fill="${statusFill(node)}" stroke="${statusStroke(node)}"/>`,
+    `<text x="${x + width - 52}" y="${y + 29}" text-anchor="middle" font-family="Inter, Arial" font-size="10" font-weight="700" fill="${statusText(node)}">${xmlText2(status)}</text>`
+  );
+  if (metrics.length > 0) {
+    lines.push(`<g class="txg-metrics">`);
+    metrics.forEach((metric, metricIndex) => {
+      const column = metricIndex % 4;
+      const row = Math.floor(metricIndex / 4);
+      const boxX = x + 14 + column * 74;
+      const boxY = cursor + row * 34;
+      lines.push(
+        `<rect x="${boxX}" y="${boxY}" width="66" height="27" rx="6" fill="#f8fafc" stroke="#e5e7eb"/>`,
+        `<text x="${boxX + 8}" y="${boxY + 11}" font-family="Inter, Arial" font-size="8" font-weight="700" fill="#64748b">${xmlText2(fit2(metric.label, 8))}</text>`,
+        `<text x="${boxX + 8}" y="${boxY + 23}" font-family="Inter, Arial" font-size="12" font-weight="700" fill="#111827">${xmlText2(metric.value)}</text>`
+      );
+    });
+    lines.push(`</g>`);
+    cursor += Math.ceil(metrics.length / 4) * 34 + 8;
+  }
+  renderRows(lines, x, cursor, width, "Facts", [...facts, ...redeemers]);
+  lines.push("</g>");
+  return lines.join("\n");
+};
+var renderUtxoNode = (layoutNode, graph, options, index, semantic) => {
+  const { node, width, height } = layoutNode;
+  const x = layoutNode.x + graph.offsetX;
+  const y = layoutNode.y + graph.offsetY;
+  const palette = nodePalette2(node);
+  const title = fit2(semanticNodeTitle(node, options), 34);
+  const subtitle = semanticNodeSubtitle(node, options);
+  const chips = usefulChips(node, options);
+  const assetRows = sectionRows2(node, options, "assets");
+  const stateRows = sectionRows2(node, options, "state");
+  const ownerRows = sectionRows2(node, options, "owner");
+  let cursor = y + 62;
+  const lines = baseNodeOpen(
+    index,
+    node,
+    semantic,
+    options,
+    x,
+    y,
+    width,
+    height,
+    palette
+  );
+  lines.push(
+    `<rect x="${x}" y="${y}" width="${width}" height="52" rx="8" fill="${palette.header}"/>`,
+    `<text x="${x + 14}" y="${y + 21}" font-family="Inter, Arial" font-size="13" font-weight="700" fill="#0f172a">${xmlText2(title)}</text>`,
+    `<text x="${x + 14}" y="${y + 39}" font-family="ui-monospace, SFMono-Regular, monospace" font-size="10" fill="#475569">${xmlText2(fit2(subtitle ?? "", 38))}</text>`
+  );
+  if (chips.length > 0) {
+    cursor = renderChips(lines, x + 14, cursor, chips, width - 28) + 8;
+  }
+  cursor = renderRows(lines, x, cursor, width, "Value", assetRows);
+  if (stateRows.length > 0) {
+    cursor = renderRows(lines, x, cursor + 2, width, "State", stateRows);
+  }
+  if (options.mode !== "overview" && ownerRows.length > 0) {
+    cursor = renderRows(lines, x, cursor + 2, width, "Owner", ownerRows);
+  }
+  lines.push("</g>");
+  return lines.join("\n");
+};
+var renderGenericNode = (layoutNode, graph, options, index, semantic) => {
+  const { node, width, height } = layoutNode;
+  const x = layoutNode.x + graph.offsetX;
+  const y = layoutNode.y + graph.offsetY;
+  const palette = nodePalette2(node);
+  const title = fit2(semanticNodeTitle(node, options), 34);
+  const subtitle = semanticNodeSubtitle(node, options);
+  const chips = usefulChips(node, options);
+  let cursor = y + 60;
+  const lines = baseNodeOpen(
+    index,
+    node,
+    semantic,
+    options,
+    x,
+    y,
+    width,
+    height,
+    palette
+  );
+  lines.push(
+    `<rect x="${x}" y="${y}" width="${width}" height="50" rx="8" fill="${palette.header}"/>`,
+    `<text x="${x + 14}" y="${y + 21}" font-family="Inter, Arial" font-size="13" font-weight="700" fill="#0f172a">${xmlText2(title)}</text>`
+  );
+  if (subtitle) {
+    lines.push(
+      `<text x="${x + 14}" y="${y + 38}" font-family="ui-monospace, SFMono-Regular, monospace" font-size="10" fill="#475569">${xmlText2(fit2(subtitle, 34))}</text>`
+    );
+  }
+  if (chips.length > 0) {
+    cursor = renderChips(lines, x + 14, cursor, chips, width - 28) + 8;
+  }
+  for (const section2 of visibleSemanticSections(node, options)) {
+    const rows = visibleSemanticRows(section2, node, options).map((row) => ({
+      ...row,
+      label: semanticFieldLabel(row, options),
+      value: semanticFieldValue(row, options)
+    }));
+    if (rows.length === 0) continue;
+    cursor = renderRows(lines, x, cursor, width, section2.title, rows);
+  }
+  lines.push("</g>");
+  return lines.join("\n");
+};
+var baseNodeOpen = (index, node, semantic, options, x, y, width, height, palette) => [
+  `<g id="txg-node-${index}" data-txg-id="${opaqueId2(semantic, node.id)}" data-txg-type="node" class="txg-node txg-${node.kind}">`,
+  `<title>${xmlText2(nodeTitle(node, options))}</title>`,
+  `<rect x="${x}" y="${y}" width="${width}" height="${height}" rx="8" fill="#ffffff" stroke="${palette.border}" stroke-width="${node.severity ? "1.8" : "1.1"}"/>`
+];
+var renderRows = (lines, x, y, width, title, rows) => {
+  if (rows.length === 0) return y;
+  lines.push(
+    `<line x1="${x + 12}" y1="${y - 9}" x2="${x + width - 12}" y2="${y - 9}" stroke="#e5e7eb"/>`,
+    `<text x="${x + 14}" y="${y}" font-family="Inter, Arial" font-size="9" font-weight="800" fill="#475569" letter-spacing="0">${xmlText2(title)}</text>`
+  );
+  let cursor = y + 19;
+  for (const row of rows) {
+    const label = fit2(row.label, 14);
+    const value = fit2(row.value, row.mono ? 26 : 24);
+    lines.push(
+      `<text x="${x + 16}" y="${cursor}" font-family="Inter, Arial" font-size="10" fill="#64748b">${xmlText2(label)}</text>`,
+      `<text x="${x + 118}" y="${cursor}" font-family="${row.mono ? "ui-monospace, SFMono-Regular, monospace" : "Inter, Arial"}" font-size="10" fill="#111827">${xmlText2(value)}</text>`
+    );
+    cursor += 21;
+  }
+  return cursor + 8;
+};
+var renderChips = (lines, x, y, chips, maxWidth) => {
+  let cursorX = x;
+  let cursorY = y;
+  for (const chip of chips) {
+    const label = fit2(chip.label, 18);
+    const width = Math.max(42, label.length * 6 + 18);
+    if (cursorX + width > x + maxWidth) {
+      cursorX = x;
+      cursorY += 24;
+    }
+    const palette = chipPalette(chip);
+    lines.push(
+      `<rect x="${cursorX}" y="${cursorY - 13}" width="${width}" height="19" rx="9.5" fill="${palette.fill}" stroke="${palette.stroke}"/>`,
+      `<text x="${cursorX + width / 2}" y="${cursorY}" text-anchor="middle" font-family="Inter, Arial" font-size="9" font-weight="700" fill="${palette.text}">${xmlText2(label)}</text>`
+    );
+    cursorX += width + 6;
+  }
+  return cursorY + 10;
+};
+var transactionMetrics = (node, options) => visibleSemanticSections(node, options).filter(
+  (section2) => ["inputs", "assets", "authority", "redeemers"].includes(section2.id)
+).flatMap(
+  (section2) => visibleSemanticRows(section2, node, options).map((row) => ({
+    ...row,
+    label: metricLabel(row.label)
+  }))
+).filter((row) => row.value !== "0");
+var sectionRows2 = (node, options, sectionId) => visibleSemanticSections(node, options).find((section2) => section2.id === sectionId)?.rows.map((row) => ({
+  ...row,
+  label: semanticFieldLabel(row, options),
+  value: semanticFieldValue(row, options)
+})) ?? [];
+var usefulChips = (node, options) => {
+  const labels = new Set(semanticChipLabels(node, options));
+  const chips = node.chips.filter((chip) => {
+    if (node.kind === "utxo" && chip.label === "resolved") return false;
+    return labels.has(chip.label);
+  });
+  if (isGenesisNode(node) && !chips.some((chip) => chip.label === "genesis")) {
+    return [{ label: "genesis", tone: "warning" }, ...chips];
+  }
+  return chips;
+};
+var metricLabel = (label) => {
+  switch (label) {
+    case "Mint policies":
+      return "Mints";
+    case "Certificates":
+      return "Certs";
+    case "Withdrawals":
+      return "Wdrls";
+    default:
+      return label;
+  }
+};
+var nodeTitle = (node, options) => [
+  semanticNodeTitle(node, options),
+  semanticNodeSubtitle(node, options),
+  ...usefulChips(node, options).map((chip) => chip.label)
+].filter(Boolean).join("\n");
+var opaqueId2 = (graph, id) => {
+  const nodeIndex = graph.nodes.findIndex((node) => node.id === id);
+  if (nodeIndex >= 0) return `node:${nodeIndex}`;
+  const edgeIndex = graph.edges.findIndex((edge) => edge.id === id);
+  return edgeIndex >= 0 ? `edge:${edgeIndex}` : id;
+};
+var nodePalette2 = (node) => {
+  if (node.severity === "error")
+    return { header: "#fee2e2", border: "#dc2626" };
+  if (isGenesisNode(node)) return { header: "#fef3c7", border: "#d97706" };
+  switch (node.kind) {
+    case "transaction":
+      return { header: "#eef2ff", border: "#6366f1" };
+    case "utxo":
+      return { header: "#ecfdf5", border: "#10b981" };
+    case "asset":
+      return { header: "#f5f3ff", border: "#7c3aed" };
+    case "withdrawal":
+      return { header: "#ecfeff", border: "#0891b2" };
+    case "certificate":
+      return { header: "#eef2ff", border: "#4f46e5" };
+    case "collateralReturn":
+      return { header: "#fffbeb", border: "#f59e0b" };
+    case "signer":
+      return { header: "#f8fafc", border: "#94a3b8" };
+    case "diagnostic":
+      return { header: "#fef2f2", border: "#dc2626" };
+  }
+};
+var chipPalette = (chip) => {
+  switch (chip.tone) {
+    case "danger":
+      return { fill: "#fee2e2", stroke: "#fca5a5", text: "#991b1b" };
+    case "warning":
+      return { fill: "#fef3c7", stroke: "#fbbf24", text: "#92400e" };
+    case "success":
+      return { fill: "#dcfce7", stroke: "#86efac", text: "#166534" };
+    case "accent":
+      return { fill: "#ede9fe", stroke: "#c4b5fd", text: "#5b21b6" };
+    case "info":
+      return { fill: "#dbeafe", stroke: "#93c5fd", text: "#1e40af" };
+    default:
+      return { fill: "#f8fafc", stroke: "#cbd5e1", text: "#334155" };
+  }
+};
+var statusFill = (node) => node.severity === "error" ? "#fee2e2" : "#ffffff";
+var statusStroke = (node) => node.severity === "error" ? "#fca5a5" : "#c7d2fe";
+var statusText = (node) => node.severity === "error" ? "#991b1b" : "#3730a3";
+var fit2 = (value, maxChars) => value.length <= maxChars ? value : `${value.slice(0, maxChars - 3)}...`;
+var xmlText2 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+// src/render/svg.ts
+var MARGIN2 = 40;
+var traceToSvg = (trace, options = {}) => {
+  const resolved = resolveVisualRendererOptions(options);
+  const semantic = formatSemanticGraph(
+    buildSemanticRenderGraph(trace, { redeemers: options.redeemers }),
+    resolved
+  );
+  const layout = layoutGraph(trace, semantic, resolved);
+  const title = options.title ?? "Lucid Evolution Transaction Graph";
+  const diagnostics = semantic.nodes.filter(
+    (node) => node.kind === "diagnostic"
+  );
+  const semanticNodes = new Map(
+    [...layout.nodes.entries()].map(([id, layoutNode]) => [
+      id,
+      layoutNode.node
+    ])
+  );
+  return [
+    `<svg xmlns="http://www.w3.org/2000/svg" role="img" width="${layout.width}" height="${layout.height}" viewBox="0 0 ${layout.width} ${layout.height}">`,
+    `<title>${xmlText3(title)}</title>`,
+    "<defs>",
+    '<marker id="txg-arrow" markerWidth="10" markerHeight="10" refX="9" refY="3" orient="auto" markerUnits="strokeWidth"><path d="M0,0 L0,6 L9,3 z" fill="context-stroke"/></marker>',
+    "</defs>",
+    `<rect width="100%" height="100%" fill="#ffffff"/>`,
+    renderTitle(title, trace, diagnostics.length),
+    ...semantic.edges.map(
+      (edge, index) => renderEdge(trace, edge, index, layout, resolved, semanticNodes, semantic)
+    ),
+    ...[...layout.nodes.values()].sort((left, right) => left.node.id.localeCompare(right.node.id)).map(
+      (node, index) => renderNode(node, layout, resolved, index, semantic)
+    ),
+    renderLegend(layout, semantic),
+    "</svg>"
+  ].join("\n");
+};
+var semanticSvgForTesting = (trace, options = {}) => {
+  const resolved = resolveVisualRendererOptions(options);
+  const semantic = formatSemanticGraph(
+    buildSemanticRenderGraph(trace, { redeemers: options.redeemers }),
+    resolved
+  );
+  return { semantic, nodes: semantic.nodes };
+};
+var renderTitle = (title, trace, diagnosticCount) => [
+  `<text x="${MARGIN2}" y="34" font-family="Inter, Arial" font-size="20" font-weight="700" fill="#111827">${xmlText3(title)}</text>`,
+  `<text x="${MARGIN2}" y="58" font-family="Inter, Arial" font-size="12" fill="#475569">${trace.transactions.length} transaction${trace.transactions.length === 1 ? "" : "s"} \xB7 ${Object.keys(trace.utxos).length} UTxOs \xB7 ${diagnosticCount} diagnostic${diagnosticCount === 1 ? "" : "s"}</text>`
+].join("\n");
+var xmlText3 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+// src/render/html.ts
+var traceToHtml = (trace, options = {}) => {
+  const resolved = resolveVisualRendererOptions(options);
+  const semantic = formatSemanticGraph(
+    buildSemanticRenderGraph(trace, { redeemers: options.redeemers }),
+    resolved
+  );
+  const title = options.title ?? "Lucid Evolution Transaction Graph";
+  const nodeIds = new Map(
+    semantic.nodes.map((node, index) => [node.id, `node:${index}`])
+  );
+  const metadata = {
+    nodes: semantic.nodes.map(
+      (node, index) => nodeMetadata(node, index, resolved, options.includeRawMetadata ?? false)
+    ),
+    edges: semantic.edges.map(
+      (edge, index) => edgeMetadata(
+        trace,
+        edge,
+        index,
+        nodeIds,
+        resolved,
+        options.includeRawMetadata ?? false
+      )
+    )
+  };
+  const filterKinds = [
+    ...new Set(semantic.edges.map((edge) => edge.kind))
+  ].sort();
+  return [
+    "<!doctype html>",
+    '<html lang="en">',
+    "<head>",
+    '<meta charset="utf-8"/>',
+    '<meta name="viewport" content="width=device-width, initial-scale=1"/>',
+    `<title>${htmlText2(title)}</title>`,
+    `<style>${cssText()}</style>`,
+    "</head>",
+    "<body>",
+    '<main class="txg-shell">',
+    '<aside class="txg-sidebar">',
+    `<h1>${htmlText2(title)}</h1>`,
+    '<input id="txg-search" type="search" placeholder="Search tx, UTxO, asset, action..." autocomplete="off"/>',
+    '<div class="txg-filters">',
+    ...filterKinds.map(
+      (kind) => `<label><input type="checkbox" data-kind="${kind}" checked/> ${kind}</label>`
+    ),
+    "</div>",
+    `<div class="txg-sidebar-legend"><h2>Legend</h2>${edgeLegendHtml(filterKinds)}</div>`,
+    '<section id="txg-details" class="txg-details">Select a node or edge.</section>',
+    "</aside>",
+    '<section class="txg-canvas">',
+    '<div class="txg-toolbar"><button id="txg-zoom-in">+</button><button id="txg-zoom-out">-</button><button id="txg-fit">Fit</button><button id="txg-reset">Reset</button><label>Inspector <select id="txg-detail-mode"><option value="overview">overview</option><option value="audit" selected>audit</option><option value="debug">debug</option></select></label><button id="txg-copy">Copy JSON</button></div>',
+    `<div id="txg-viewport" class="txg-viewport">${traceToSvg(trace, options)}</div>`,
+    "</section>",
+    "</main>",
+    `<script type="application/json" id="txg-data">${scriptJson(metadata)}</script>`,
+    `<script>${clientScript()}</script>`,
+    "</body>",
+    "</html>"
+  ].join("\n");
+};
+var nodeMetadata = (node, index, resolved, includeRawMetadata) => ({
+  id: `node:${index}`,
+  graphId: includeRawMetadata ? node.id : void 0,
+  kind: node.kind,
+  title: semanticNodeTitle(node, resolved),
+  subtitle: semanticNodeSubtitle(node, resolved),
+  chips: semanticChipLabels(node, resolved),
+  sections: visibleSemanticSections(node, resolved).map((section2) => ({
+    title: section2.title,
+    rows: visibleSemanticRows(section2, node, resolved).map((row) => ({
+      label: semanticFieldLabel(row, resolved),
+      value: semanticFieldValue(row, resolved)
+    }))
+  })),
+  ...includeRawMetadata ? { rawRef: node.rawRef } : {}
+});
+var edgeMetadata = (trace, edge, index, nodeIds, resolved, includeRawMetadata) => ({
+  id: `edge:${index}`,
+  graphId: includeRawMetadata ? edge.id : void 0,
+  kind: edge.kind,
+  title: semanticEdgeLabel(trace, edge, resolved),
+  from: includeRawMetadata ? edge.from : nodeIds.get(edge.from),
+  to: includeRawMetadata ? edge.to : nodeIds.get(edge.to),
+  action: edge.action,
+  redeemerKey: edge.redeemerKey,
+  ...includeRawMetadata ? { targetRef: edge.targetRef, rawRef: edge.rawRef } : {}
+});
+var edgeLegendHtml = (kinds) => kinds.map((kind) => {
+  const style = visualEdgeStyle(kind);
+  return [
+    '<div class="txg-legend-row">',
+    `<svg width="42" height="14" viewBox="0 0 42 14" aria-hidden="true"><line x1="2" y1="7" x2="36" y2="7" stroke="${style.color}" stroke-width="2.4"${htmlDashArray(style.style)}/></svg>`,
+    `<span>${htmlText2(kind)}</span>`,
+    "</div>"
+  ].join("");
+}).join("");
+var htmlDashArray = (style) => style === "solid" ? "" : style === "dotted" ? ' stroke-dasharray="2 4"' : ' stroke-dasharray="6 5"';
+var cssText = () => `
+html, body { height: 100%; }
+body { margin: 0; overflow: hidden; font-family: Inter, Arial, sans-serif; color: #111827; background: #f8fafc; }
+.txg-shell { display: grid; grid-template-columns: 320px 1fr; height: 100vh; min-height: 0; }
+.txg-sidebar { position: sticky; top: 0; max-height: 100vh; border-right: 1px solid #d1d5db; background: #ffffff; padding: 16px; overflow: auto; }
+.txg-sidebar h1 { font-size: 16px; margin: 0 0 14px; }
+#txg-search { box-sizing: border-box; width: 100%; padding: 8px 10px; border: 1px solid #cbd5e1; border-radius: 6px; }
+.txg-filters { display: grid; grid-template-columns: 1fr 1fr; gap: 6px 10px; margin: 14px 0; font-size: 12px; }
+.txg-sidebar-legend { border-top: 1px solid #e5e7eb; padding-top: 12px; margin-bottom: 12px; }
+.txg-sidebar-legend h2 { font-size: 12px; margin: 0 0 8px; color: #111827; }
+.txg-legend-row { display: inline-flex; align-items: center; gap: 6px; min-width: 132px; margin: 0 6px 6px 0; font-size: 11px; color: #374151; }
+.txg-details { border-top: 1px solid #e5e7eb; padding-top: 12px; font-size: 12px; line-height: 1.45; }
+.txg-details h2 { font-size: 14px; margin: 0 0 8px; }
+.txg-details table { border-collapse: collapse; width: 100%; margin: 8px 0; }
+.txg-details td { border-top: 1px solid #e5e7eb; padding: 4px 0; vertical-align: top; }
+.txg-details td:first-child { color: #64748b; width: 38%; }
+.txg-canvas { display: grid; grid-template-rows: auto 1fr; min-width: 0; min-height: 0; overflow: hidden; }
+.txg-toolbar { display: flex; gap: 8px; padding: 10px; border-bottom: 1px solid #d1d5db; background: #ffffff; }
+.txg-toolbar button { border: 1px solid #cbd5e1; background: #ffffff; border-radius: 6px; padding: 6px 10px; }
+.txg-toolbar label { display: inline-flex; align-items: center; gap: 6px; font-size: 12px; color: #475569; }
+.txg-toolbar select { border: 1px solid #cbd5e1; border-radius: 6px; padding: 5px 8px; background: #ffffff; }
+.txg-viewport { min-height: 0; overflow: auto; padding: 18px; transform-origin: top left; cursor: grab; }
+.txg-viewport.txg-panning { cursor: grabbing; user-select: none; }
+.txg-viewport svg { background: #ffffff; box-shadow: 0 1px 4px rgba(15, 23, 42, 0.12); }
+.txg-hidden { opacity: 0.08; pointer-events: none; }
+.txg-match rect:first-of-type { stroke-width: 3px; }
+.txg-selected rect:first-of-type { stroke-width: 3px; stroke: #0f172a; }
+.txg-connected path { stroke-width: 3px; }
+.txg-details pre { white-space: pre-wrap; word-break: break-word; background: #f8fafc; border: 1px solid #e5e7eb; border-radius: 6px; padding: 8px; }
+@media (max-width: 800px) { body { overflow: auto; } .txg-shell { grid-template-columns: 1fr; height: auto; min-height: 100vh; } .txg-sidebar { position: static; max-height: none; border-right: 0; border-bottom: 1px solid #d1d5db; } .txg-canvas { min-height: 70vh; } }
+`;
+var clientScript = () => `
+const data = JSON.parse(document.getElementById("txg-data").textContent);
+let selected = null;
+let zoom = 1;
+const viewport = document.getElementById("txg-viewport");
+const svg = viewport.querySelector("svg");
+const details = document.getElementById("txg-details");
+const search = document.getElementById("txg-search");
+const detailMode = document.getElementById("txg-detail-mode");
+const checks = [...document.querySelectorAll("[data-kind]")];
+const byId = new Map([...data.nodes, ...data.edges].map((item) => [item.id, item]));
+const itemElements = new Map([...document.querySelectorAll(".txg-node,.txg-edge")].map((el) => [el.dataset.txgId, el]));
+
+const setZoom = (nextZoom) => {
+  zoom = Math.max(0.25, Math.min(2.5, nextZoom));
+  viewport.style.zoom = zoom;
+};
+
+const itemBox = (item) => {
+  const el = item ? itemElements.get(item.id) : null;
+  if (!el || !el.getBBox) return null;
+  try { return el.getBBox(); } catch (_error) { return null; }
+};
+
+const centerBox = (box) => {
+  if (!box) return;
+  viewport.scrollLeft = Math.max(0, (box.x + box.width / 2) * zoom - viewport.clientWidth / 2);
+  viewport.scrollTop = Math.max(0, (box.y + box.height / 2) * zoom - viewport.clientHeight / 2);
+};
+
+const primaryTransaction = () =>
+  data.nodes.find((node) => node.kind === "transaction" && node.chips?.includes("failed")) ||
+  [...data.nodes].reverse().find((node) => node.kind === "transaction") ||
+  data.nodes[0];
+
+const fitToView = (overview = false) => {
+  if (!svg?.viewBox?.baseVal) return;
+  const viewBox = svg.viewBox.baseVal;
+  const widthZoom = (viewport.clientWidth - 36) / Math.max(1, viewBox.width);
+  const readableFloor = viewport.clientWidth < 720 ? 0.55 : 0.72;
+  setZoom(
+    overview
+      ? Math.min(1, Math.max(0.35, widthZoom))
+      : Math.min(1, Math.max(readableFloor, widthZoom)),
+  );
+  requestAnimationFrame(() => centerBox(itemBox(primaryTransaction())));
+};
+
+const renderDetails = (item) => {
+  selected = item;
+  if (!item) { details.textContent = "Select a node or edge."; return; }
+  const mode = detailMode.value;
+  const summaryRows = [["kind", item.kind], ...(item.subtitle ? [["subtitle", item.subtitle]] : []), ...(item.chips?.length ? [["tags", item.chips.join(", ")]] : [])];
+  const auditRows = item.sections ? item.sections.flatMap((section) => section.rows.map((row) => [section.title + "." + row.label, row.value])) : Object.entries(item).filter(([key]) => !["sections"].includes(key)).map(([key, value]) => [key, typeof value === "string" ? value : JSON.stringify(value)]);
+  if (mode === "debug") {
+    details.innerHTML = "<h2>" + escapeHtml(item.title || item.id) + "</h2><pre>" + escapeHtml(JSON.stringify(item, null, 2)) + "</pre>";
+    return;
+  }
+  const rows = mode === "overview" ? summaryRows : [...summaryRows, ...auditRows];
+  details.innerHTML = "<h2>" + escapeHtml(item.title || item.id) + "</h2>" + "<table>" + rows.map(([key, value]) => "<tr><td>" + escapeHtml(String(key)) + "</td><td>" + escapeHtml(String(value)) + "</td></tr>").join("") + "</table>";
+};
+
+const textFor = (item) => JSON.stringify(item).toLowerCase();
+const applyFilters = () => {
+  const query = search.value.toLowerCase();
+  const enabled = new Set(checks.filter((check) => check.checked).map((check) => check.dataset.kind));
+  const visibleEdgeIds = new Set(data.edges.filter((edge) => enabled.has(edge.kind) && (!query || textFor(edge).includes(query))).map((edge) => edge.id));
+  const matchingNodeIds = new Set(data.nodes.filter((node) => query && textFor(node).includes(query)).map((node) => node.id));
+  document.querySelectorAll(".txg-edge").forEach((edge) => {
+    edge.classList.toggle("txg-hidden", !visibleEdgeIds.has(edge.dataset.txgId));
+  });
+  document.querySelectorAll(".txg-node").forEach((node) => {
+    node.classList.toggle("txg-match", matchingNodeIds.has(node.dataset.txgId));
+  });
+};
+
+document.querySelectorAll(".txg-node,.txg-edge").forEach((el) => {
+  el.addEventListener("click", () => {
+    const item = byId.get(el.dataset.txgId) || null;
+    renderDetails(item);
+    document.querySelectorAll(".txg-selected,.txg-connected").forEach((candidate) => candidate.classList.remove("txg-selected", "txg-connected"));
+    el.classList.add("txg-selected");
+    if (item?.from) itemElements.get(item.from)?.classList.add("txg-connected");
+    if (item?.to) itemElements.get(item.to)?.classList.add("txg-connected");
+    if (item?.id?.startsWith("node:")) {
+      data.edges.filter((edge) => edge.from === item.id || edge.to === item.id).forEach((edge) => itemElements.get(edge.id)?.classList.add("txg-connected"));
+    }
+  });
+});
+search.addEventListener("input", applyFilters);
+checks.forEach((check) => check.addEventListener("change", applyFilters));
+detailMode.addEventListener("change", () => renderDetails(selected));
+document.getElementById("txg-zoom-in").addEventListener("click", () => setZoom(zoom + 0.1));
+document.getElementById("txg-zoom-out").addEventListener("click", () => setZoom(zoom - 0.1));
+document.getElementById("txg-fit").addEventListener("click", () => fitToView(true));
+document.getElementById("txg-reset").addEventListener("click", () => { search.value = ""; checks.forEach((check) => check.checked = true); applyFilters(); fitToView(false); });
+document.getElementById("txg-copy").addEventListener("click", async () => { if (selected) await navigator.clipboard.writeText(JSON.stringify(selected, null, 2)); });
+
+let panStart = null;
+viewport.addEventListener("pointerdown", (event) => {
+  if (event.target.closest(".txg-node,.txg-edge")) return;
+  panStart = { x: event.clientX, y: event.clientY, left: viewport.scrollLeft, top: viewport.scrollTop };
+  viewport.classList.add("txg-panning");
+  viewport.setPointerCapture(event.pointerId);
+});
+viewport.addEventListener("pointermove", (event) => {
+  if (!panStart) return;
+  viewport.scrollLeft = panStart.left - (event.clientX - panStart.x);
+  viewport.scrollTop = panStart.top - (event.clientY - panStart.y);
+});
+viewport.addEventListener("pointerup", (event) => {
+  panStart = null;
+  viewport.classList.remove("txg-panning");
+  viewport.releasePointerCapture(event.pointerId);
+});
+window.addEventListener("resize", () => fitToView(false));
+requestAnimationFrame(() => fitToView(false));
+
+const escapeHtml = (value) => value.replace(/[&<>"]/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", "\\"": "&quot;" }[char]));
+`;
+var htmlText2 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var scriptJson = (value) => JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+
+// src/render/mermaid.ts
+var traceToMermaid = (trace, options = {}) => {
+  if (options.legacy) return traceToLegacyMermaid(trace, options);
+  const resolved = resolveVisualRendererOptions(options);
+  const graph = formatSemanticGraph(
+    buildSemanticRenderGraph(trace, {
+      redeemers: options.redeemers
+    }),
+    resolved
+  );
+  const nodeIds = new Map(
+    graph.nodes.map((node, index) => [node.id, `n${index}`])
+  );
+  const semanticNodes = new Map(
+    graph.nodes.map((node) => [node.id, node])
+  );
+  const lines = [
+    `flowchart ${options.direction ?? "LR"}`,
+    "  classDef tx fill:#eef2ff,stroke:#6366f1,color:#111827;",
+    "  classDef utxo fill:#ecfdf5,stroke:#10b981,color:#111827;",
+    "  classDef asset fill:#f5f3ff,stroke:#7c3aed,color:#111827;",
+    "  classDef authority fill:#f3f4f6,stroke:#6b7280,color:#111827;",
+    "  classDef governance fill:#eef2ff,stroke:#4f46e5,color:#111827;",
+    "  classDef collateral fill:#fffbeb,stroke:#f59e0b,color:#111827;",
+    "  classDef unresolved fill:#fee2e2,stroke:#dc2626,color:#111827;",
+    "  classDef genesis fill:#fef3c7,stroke:#d97706,color:#111827;"
+  ];
+  const linkStyles = [];
+  for (const node of graph.nodes) {
+    const id = nodeIds.get(node.id);
+    lines.push(`  ${id}${semanticNodeShape(node, resolved)}`);
+    lines.push(`  class ${id} ${semanticNodeClass(node)};`);
+  }
+  for (const [index, edge] of graph.edges.entries()) {
+    const style = visualEdgeStyle(edge.kind);
+    const scriptFocus = resolved.view === "scriptInteraction" && isScriptInteractionEdge(edge, semanticNodes);
+    lines.push(
+      `  ${nodeIds.get(edge.from)} -->|${mermaidText(
+        semanticEdgeLabel(trace, edge, resolved)
+      )}| ${nodeIds.get(edge.to)}`
+    );
+    linkStyles.push(
+      `  linkStyle ${index} stroke:${style.color},color:${style.color}${scriptFocus ? ",stroke-width:3px" : ""}${style.style === "solid" ? "" : ",stroke-dasharray: 5 5"};`
+    );
+  }
+  return `${[...lines, ...linkStyles].join("\n")}
+`;
+};
+var semanticNodeShape = (node, options) => {
+  const label = mermaidText(semanticNodeLabel2(node, options));
+  switch (node.kind) {
+    case "transaction":
+      return `["${label}"]`;
+    case "utxo":
+      return node.severity === "error" ? `{{"${label}"}}` : `("${label}")`;
+    case "asset":
+      return `(["${label}"])`;
+    case "signer":
+      return `{{"${label}"}}`;
+    case "withdrawal":
+    case "certificate":
+    case "collateralReturn":
+    case "diagnostic":
+      return `["${label}"]`;
+  }
+};
+var semanticNodeLabel2 = (node, options) => {
+  const subtitle = semanticNodeSubtitle(node, options);
+  const chipLabels = semanticChipLabels(node, options);
+  const chips = chipLabels.length > 0 ? chipLabels.join(" | ") : void 0;
+  return [
+    semanticNodeTitle(node, options),
+    ...subtitle ? [subtitle] : [],
+    ...chips ? [chips] : [],
+    ...visibleSemanticSections(node, options).map((section2) => mermaidSectionLine(section2, node, options)).filter((line) => Boolean(line))
+  ].join("<br/>");
+};
+var mermaidSectionLine = (section2, node, options) => {
+  const rows = visibleSemanticRows(section2, node, options);
+  if (rows.length === 0) return void 0;
+  return `${section2.title}: ${rows.map((row) => mermaidRowText(section2, row, options)).join(", ")}`;
+};
+var mermaidRowText = (section2, row, options) => {
+  const value = semanticFieldValue(row, options);
+  return section2.id === "assets" && row.id.startsWith("asset:") ? `${value} ${semanticFieldLabel(row, options)}` : `${semanticFieldLabel(row, options)} ${value}`;
+};
+var semanticNodeClass = (node) => {
+  if (node.severity === "error") return "unresolved";
+  if (isGenesisNode(node)) return "genesis";
+  if (node.rawRef.type === "diagnostic" && node.rawRef.code === "collapsed") {
+    return "authority";
+  }
+  switch (node.kind) {
+    case "transaction":
+      return "tx";
+    case "utxo":
+      return "utxo";
+    case "asset":
+      return "asset";
+    case "withdrawal":
+    case "signer":
+      return "authority";
+    case "certificate":
+      return "governance";
+    case "collateralReturn":
+      return "collateral";
+    case "diagnostic":
+      return "unresolved";
+  }
+};
+var traceToLegacyMermaid = (trace, options = {}) => {
+  const graph = buildRenderGraph(trace);
+  const nodeIds = new Map(
+    graph.nodes.map((node, index) => [node.id, `n${index}`])
+  );
+  const lines = [
+    `flowchart ${options.direction ?? "LR"}`,
+    "  classDef tx fill:#eef2ff,stroke:#6366f1,color:#111827;",
+    "  classDef utxo fill:#ecfdf5,stroke:#10b981,color:#111827;",
+    "  classDef unresolved fill:#fee2e2,stroke:#dc2626,color:#111827;",
+    "  classDef genesis fill:#fef3c7,stroke:#d97706,color:#111827;",
+    "  classDef external fill:#f9fafb,stroke:#9ca3af,color:#111827;"
+  ];
+  for (const node of graph.nodes) {
+    lines.push(`  ${nodeIds.get(node.id)}${legacyNodeShape2(node)}`);
+    lines.push(
+      `  class ${nodeIds.get(node.id)} ${node.unresolved ? "unresolved" : node.genesis ? "genesis" : legacyNodeClass(node)};`
+    );
+  }
+  for (const edge of graph.edges) {
+    const style = edgeStyle(edge.kind);
+    lines.push(
+      `  ${nodeIds.get(edge.from)} -->|${mermaidText(style.label)}| ${nodeIds.get(
+        edge.to
+      )}`
+    );
+  }
+  return `${lines.join("\n")}
+`;
+};
+var legacyNodeShape2 = (node) => {
+  const label = mermaidText(node.label);
+  switch (node.kind) {
+    case "transaction":
+      return `["${label}"]`;
+    case "utxo":
+      return node.unresolved ? `{{"${label}"}}` : `("${label}")`;
+    case "asset":
+      return `(["${label}"])`;
+    case "signer":
+      return `{{"${label}"}}`;
+    case "withdrawal":
+    case "certificate":
+    case "collateralReturn":
+    case "external":
+      return `["${label}"]`;
+  }
+};
+var legacyNodeClass = (node) => node.kind === "transaction" ? "tx" : node.kind === "utxo" ? "utxo" : "external";
+var mermaidText = (value) => value.replace(/\\n/g, "<br/>").replace(/\n/g, "<br/>").replace(/\\/g, "\\\\").replace(/"/g, "'").replace(/\|/g, "/");
+
+// src/provider-wrapper.ts
+var wrapProvider = (provider, graph, options = {}) => {
+  graph.resolveWith((outRefs) => provider.getUtxosByOutRef(outRefs));
+  return new Proxy(provider, {
+    get(target, property, receiver) {
+      if (property === "submitTx") {
+        return (tx) => submitTx(target, graph, tx, options);
+      }
+      if (property === "evaluateTx") {
+        return (tx, additionalUTxOs) => evaluateTx(target, graph, tx, additionalUTxOs, options);
+      }
+      const value = Reflect.get(target, property, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+};
+var submitTx = async (provider, graph, tx, options) => {
+  const parsed = await graph.record(tx, {
+    label: options.submitLabel,
+    status: "signed"
+  });
+  try {
+    const txHash = await provider.submitTx(tx);
+    await recordSubmitted(graph, tx, options.submitLabel, parsed.hash);
+    if (txHash !== parsed.hash) {
+      graph.addWarning({
+        code: "provider-tx-hash-mismatch",
+        message: `Provider returned transaction hash ${txHash}, but the submitted body hashes to ${parsed.hash}`,
+        txHash: parsed.hash
+      });
+    }
+    return txHash;
+  } catch (error) {
+    await recordFailed(graph, tx, options.submitLabel, error);
+    throw error;
+  }
+};
+var evaluateTx = async (provider, graph, tx, additionalUTxOs, options) => {
+  if (options.recordEvaluate === false) {
+    return provider.evaluateTx(tx, additionalUTxOs);
+  }
+  if (additionalUTxOs && additionalUTxOs.length > 0) {
+    graph.addResolvedUtxos(additionalUTxOs);
+  }
+  await graph.record(tx, {
+    label: options.evaluateLabel,
+    status: "built"
+  });
+  try {
+    const evaluation = await provider.evaluateTx(tx, additionalUTxOs);
+    await recordEvaluation(graph, tx, options.evaluateLabel, evaluation);
+    return evaluation;
+  } catch (error) {
+    await recordFailed(graph, tx, options.evaluateLabel, error);
+    throw error;
+  }
+};
+var recordSubmitted = async (graph, tx, label, txHash) => {
+  try {
+    await graph.record(tx, { label, status: "submitted" });
+  } catch (error) {
+    graph.addWarning(
+      traceRecordWarning("trace-submit-record-error", txHash, error)
+    );
+  }
+};
+var recordEvaluation = async (graph, tx, label, evaluation) => {
+  try {
+    await graph.record(tx, {
+      label,
+      status: "built",
+      evaluation: evaluation.map(traceEvaluationRedeemer)
+    });
+  } catch (error) {
+    graph.addWarning(
+      traceRecordWarning("trace-evaluate-record-error", void 0, error)
+    );
+  }
+};
+var recordFailed = async (graph, tx, label, error) => {
+  try {
+    await graph.record(tx, {
+      label,
+      status: "failed",
+      failureMessage: errorMessage2(error)
+    });
+  } catch {
+  }
+};
+var traceEvaluationRedeemer = (redeemer) => ({
+  tag: redeemer.redeemer_tag,
+  redeemerIndex: redeemer.redeemer_index,
+  exUnits: {
+    mem: redeemer.ex_units.mem.toString(),
+    steps: redeemer.ex_units.steps.toString()
+  }
+});
+var traceRecordWarning = (code, txHash, error) => ({
+  code,
+  message: errorMessage2(error),
+  ...txHash ? { txHash } : {}
+});
+var errorMessage2 = (error) => error instanceof Error ? error.message : String(error);
+
+// src/graph.ts
+var createTxGraph = (options = {}) => {
+  const transactions = [];
+  const preloadedUtxos = [];
+  let utxos = /* @__PURE__ */ new Map();
+  let edges = [];
+  let warnings = [];
+  let spentBy = /* @__PURE__ */ new Map();
+  let resolutionCache = createResolutionCache();
+  const externalWarnings = [];
+  const resolvers = options.resolver ? [options.resolver] : [];
+  const aliases = {
+    assets: sortRecord({
+      ...options.aliases?.assets ?? {},
+      ...options.assets ?? {}
+    }),
+    addresses: sortRecord({
+      ...options.aliases?.addresses ?? {},
+      ...options.addresses ?? {}
+    })
+  };
+  const taggers = [...options.labels ?? []];
+  const graph = {
+    record: async (input, recordOptions = {}) => {
+      const parsed = parseTransaction(input, recordOptions);
+      const nextTransaction = withFailureMessage(parsed, recordOptions);
+      const existingIndex = transactions.findIndex(
+        (transaction2) => transaction2.hash === nextTransaction.hash
+      );
+      const transaction = existingIndex >= 0 ? mergeRecordedTransaction(
+        transactions[existingIndex],
+        nextTransaction
+      ) : nextTransaction;
+      if (existingIndex >= 0) {
+        transactions[existingIndex] = transaction;
+        await rebuildTrace();
+      } else {
+        transactions.push(transaction);
+        await appendTransactionToTrace(transaction);
+      }
+      return jsonClone(transaction);
+    },
+    recordCbor: async (cbor, recordOptions = {}) => graph.record(cbor, recordOptions),
+    addResolvedUtxos: (resolvedUtxos) => {
+      preloadedUtxos.push(...resolvedUtxos);
+      resolutionCache.addResolvedUtxos(resolvedUtxos);
+    },
+    resolveWith: (resolver) => {
+      resolvers.push(resolver);
+    },
+    addWarning: (warning) => {
+      externalWarnings.push(jsonClone(warning));
+    },
+    wrapProvider: (provider, wrapperOptions = {}) => wrapProvider(provider, graph, wrapperOptions),
+    toJSON: () => {
+      const trace = {
+        version: 1,
+        ...options.createdAt ? { createdAt: options.createdAt } : {},
+        transactions: transactions.map(jsonClone),
+        utxos: sortedUtxoRecord(utxos),
+        edges: sortedEdges2(edges),
+        warnings: [...warnings, ...externalWarnings].map(jsonClone),
+        aliases
+      };
+      return jsonClone(trace);
+    },
+    toSemantic: (renderOptions = {}) => buildSemanticRenderGraph(graph.toJSON(), renderOptions),
+    toDot: (renderOptions = {}) => traceToDot(graph.toJSON(), renderOptions),
+    toHtml: (renderOptions = {}) => traceToHtml(graph.toJSON(), renderOptions),
+    toMermaid: (renderOptions = {}) => traceToMermaid(graph.toJSON(), renderOptions),
+    toSvg: (renderOptions = {}) => traceToSvg(graph.toJSON(), renderOptions)
+  };
+  const rebuildTrace = async () => {
+    utxos = /* @__PURE__ */ new Map();
+    edges = [];
+    warnings = [];
+    spentBy = /* @__PURE__ */ new Map();
+    resolutionCache = createResolutionCache();
+    resolutionCache.addResolvedUtxos(preloadedUtxos);
+    for (const transaction of transactions) {
+      await appendTransactionToTrace(transaction);
+    }
+  };
+  const appendTransactionToTrace = async (transaction) => {
+    await resolveTransactionInputs(transaction);
+    recordDoubleSpends(transaction);
+    addProducedOutputs(transaction);
+    addEdges(transaction);
+    if (transaction.status === "failed") {
+      warnings.push({
+        code: "failed-transaction",
+        message: transaction.failureMessage ?? `Transaction ${transaction.hash} was recorded as failed`,
+        txHash: transaction.hash
+      });
+    }
+  };
+  const resolveTransactionInputs = async (transaction) => {
+    const allInputs = [
+      ...transaction.inputs,
+      ...transaction.referenceInputs,
+      ...transaction.collateralInputs
+    ];
+    if (allInputs.length === 0) return;
+    const resolution = await resolutionCache.resolveOutRefs(allInputs, {
+      provider: options.provider,
+      resolver: resolvers.length > 0 ? resolveWithUserResolvers : void 0
+    });
+    for (const warning of resolution.warnings) {
+      warnings.push({ ...warning, txHash: transaction.hash });
+    }
+    for (const utxo of resolution.utxos) {
+      setInputUtxo(tagUtxo(utxo, "input", transaction));
+    }
+    const resolvedByKey = new Map(
+      resolution.utxos.map((utxo) => [outRefKey(utxo), utxo])
+    );
+    warnUnresolvedInputs(
+      transaction,
+      "spend",
+      transaction.inputs,
+      resolvedByKey
+    );
+    warnUnresolvedInputs(
+      transaction,
+      "reference",
+      transaction.referenceInputs,
+      resolvedByKey
+    );
+    warnUnresolvedInputs(
+      transaction,
+      "collateral",
+      transaction.collateralInputs,
+      resolvedByKey
+    );
+  };
+  const resolveWithUserResolvers = async (outRefs) => {
+    const resolved = [];
+    let missing = [...outRefs];
+    for (const resolver of resolvers) {
+      if (missing.length === 0) break;
+      const resolverUtxos = await resolver(missing);
+      resolved.push(...resolverUtxos);
+      const resolvedKeys = new Set(resolverUtxos.map(outRefKey));
+      missing = missing.filter(
+        (outRef) => !resolvedKeys.has(outRefKey(outRef))
+      );
+    }
+    return resolved;
+  };
+  const addProducedOutputs = (transaction) => {
+    const outputs = transaction.outputs.map(
+      (utxo) => tagUtxo(utxo, "output", transaction)
+    );
+    for (const utxo of outputs) {
+      utxos.set(outRefKey(utxo), jsonClone(utxo));
+    }
+    if (transaction.status !== "failed") {
+      resolutionCache.addTransactionOutputs({ outputs });
+    }
+    updateStoredTransactionOutputs(transaction.hash, outputs);
+  };
+  const recordDoubleSpends = (transaction) => {
+    if (transaction.status === "failed") return;
+    const seenInTx = /* @__PURE__ */ new Set();
+    for (const input of transaction.inputs) {
+      const key = outRefKey(input);
+      const previousTxHash = seenInTx.has(key) ? transaction.hash : spentBy.get(key);
+      if (previousTxHash) {
+        warnings.push({
+          code: "duplicate-spend",
+          message: previousTxHash === transaction.hash ? `Transaction ${transaction.hash} spends ${key} more than once` : `Transaction ${transaction.hash} spends ${key}, already spent by ${previousTxHash}`,
+          txHash: transaction.hash,
+          outRef: input
+        });
+      }
+      seenInTx.add(key);
+      if (!spentBy.has(key)) spentBy.set(key, transaction.hash);
+    }
+  };
+  const setInputUtxo = (utxo) => {
+    const key = outRefKey(utxo);
+    const existing = utxos.get(key);
+    if (existing?.resolution === "resolved" && utxo.resolution === "unresolved") {
+      return;
+    }
+    utxos.set(key, jsonClone(utxo));
+  };
+  const warnUnresolvedInputs = (transaction, kind, inputs, resolvedByKey) => {
+    for (const input of inputs) {
+      const resolved = resolvedByKey.get(outRefKey(input));
+      if (resolved?.resolution !== "unresolved") continue;
+      warnings.push({
+        code: `unresolved-${kind}-input`,
+        message: `Transaction ${transaction.hash} has unresolved ${kind} input ${outRefKey(input)} (${resolved.unresolvedReason ?? "unresolved"})`,
+        txHash: transaction.hash,
+        outRef: input
+      });
+    }
+  };
+  const addEdges = (transaction) => {
+    addInputEdges2("spends", transaction.inputs, transaction);
+    addInputEdges2("reads", transaction.referenceInputs, transaction);
+    addInputEdges2("collateral", transaction.collateralInputs, transaction);
+    for (const output of transaction.outputs) {
+      edges.push({
+        kind: "produces",
+        from: txNodeId2(transaction.hash),
+        to: utxoNodeId3(output)
+      });
+    }
+    if (transaction.collateralReturn) {
+      edges.push({
+        kind: "collateralReturn",
+        from: txNodeId2(transaction.hash),
+        to: collateralReturnNodeId2(transaction.hash)
+      });
+    }
+    addAssetEdges("mints", transaction.hash, transaction.mintedAssets);
+    addAssetEdges("burns", transaction.hash, transaction.burnedAssets);
+    for (const withdrawal of transaction.withdrawals) {
+      edges.push({
+        kind: "withdraws",
+        from: withdrawalNodeId2(withdrawal.rewardAddress),
+        to: txNodeId2(transaction.hash)
+      });
+    }
+    for (const certificate of transaction.certificates) {
+      edges.push({
+        kind: "certifies",
+        from: txNodeId2(transaction.hash),
+        to: certificateNodeId2(transaction.hash, certificate.index)
+      });
+    }
+    for (const signer of transaction.requiredSigners) {
+      edges.push({
+        kind: "requiresSigner",
+        from: signerNodeId2(signer),
+        to: txNodeId2(transaction.hash)
+      });
+    }
+  };
+  const addInputEdges2 = (kind, inputs, transaction) => {
+    for (const input of inputs) {
+      edges.push({
+        kind,
+        from: utxoNodeId3(input),
+        to: txNodeId2(transaction.hash)
+      });
+    }
+  };
+  const addAssetEdges = (kind, txHash, assets) => {
+    for (const unit of Object.keys(assets).sort()) {
+      edges.push(
+        kind === "mints" ? {
+          kind,
+          from: txNodeId2(txHash),
+          to: assetNodeId(unit)
+        } : {
+          kind,
+          from: assetNodeId(unit),
+          to: txNodeId2(txHash)
+        }
+      );
+    }
+  };
+  const tagUtxo = (utxo, direction, transaction) => {
+    if (taggers.length === 0) return utxo;
+    const tags = new Set(utxo.tags);
+    for (const tagger of taggers) {
+      const nextTags = tagger({
+        utxo,
+        direction,
+        transaction,
+        graph: currentTrace()
+      });
+      for (const tag of normalizeTags(nextTags)) {
+        tags.add(tag);
+      }
+    }
+    return {
+      ...utxo,
+      tags: [...tags].sort()
+    };
+  };
+  const updateStoredTransactionOutputs = (txHash, outputs) => {
+    const index = transactions.findIndex(
+      (transaction) => transaction.hash === txHash
+    );
+    if (index >= 0) {
+      transactions[index] = {
+        ...transactions[index],
+        outputs: outputs.map(jsonClone)
+      };
+    }
+  };
+  const currentTrace = () => ({
+    version: 1,
+    ...options.createdAt ? { createdAt: options.createdAt } : {},
+    transactions: transactions.map(jsonClone),
+    utxos: sortedUtxoRecord(utxos),
+    edges: sortedEdges2(edges),
+    warnings: [...warnings, ...externalWarnings].map(jsonClone),
+    aliases
+  });
+  return graph;
+};
+var withFailureMessage = (transaction, options) => ({
+  ...transaction,
+  ...options.failureMessage ? { failureMessage: options.failureMessage } : {},
+  ...options.evaluation ? { evaluation: [...options.evaluation] } : {}
+});
+var mergeRecordedTransaction = (existing, next) => {
+  const failureMessage = next.status === "failed" ? next.failureMessage ?? existing.failureMessage : void 0;
+  const evaluation = next.evaluation ?? (next.status === "failed" ? void 0 : existing.evaluation);
+  return {
+    ...next,
+    label: next.label ?? existing.label,
+    ...failureMessage !== void 0 ? { failureMessage } : {},
+    ...evaluation !== void 0 ? { evaluation } : {}
+  };
+};
+var sortedUtxoRecord = (utxos) => {
+  const result = {};
+  for (const key of [...utxos.keys()].sort()) {
+    const utxo = utxos.get(key);
+    if (utxo) result[key] = jsonClone(utxo);
+  }
+  return result;
+};
+var sortedEdges2 = (edges) => [...edges].sort((left, right) => {
+  const leftKey = edgeSortKey2(left);
+  const rightKey = edgeSortKey2(right);
+  return leftKey.localeCompare(rightKey);
+});
+var edgeSortKey2 = (edge) => `${edge.from}\0${edge.kind}\0${edge.to}`;
+var sortRecord = (record) => {
+  const result = {};
+  for (const key of Object.keys(record).sort()) {
+    result[key] = record[key];
+  }
+  return result;
+};
+var normalizeTags = (tags) => {
+  if (!tags) return [];
+  const values = Array.isArray(tags) ? tags : [tags];
+  return values.map((tag) => tag.trim()).filter((tag) => tag.length > 0);
+};
+var jsonClone = (value) => JSON.parse(JSON.stringify(value));
+var txNodeId2 = (txHash) => `tx:${txHash}`;
+var utxoNodeId3 = (outRef) => `utxo:${outRefKey(outRef)}`;
+var assetNodeId = (unit) => `asset:${unit}`;
+var withdrawalNodeId2 = (rewardAddress) => `withdrawal:${rewardAddress}`;
+var certificateNodeId2 = (txHash, index) => `certificate:${txHash}#${index}`;
+var signerNodeId2 = (keyHash) => `signer:${keyHash}`;
+var collateralReturnNodeId2 = (txHash) => `collateral-return:${txHash}`;
+
+// src/labels.ts
+var tagByAddress = (label, address) => ({ utxo }) => utxo.address === address ? label : void 0;
+var tagByCredential = (label, credential) => ({ utxo }) => credentialEquals(utxo.paymentCredential, credential) || credentialEquals(utxo.stakeCredential, credential) ? label : void 0;
+var tagByUnit = (label, unit) => ({ utxo }) => Object.hasOwn(utxo.assets, unit) ? label : void 0;
+var tagByPolicyId = (label, policyId) => ({ utxo }) => Object.keys(utxo.assets).some(
+  (unit) => unit !== "lovelace" && unit.startsWith(policyId)
+) ? label : void 0;
+var tagByDatumHash = (label, datumHash) => ({ utxo }) => utxo.datumHash === datumHash ? label : void 0;
+var tagByDatum = (label, predicate) => (context) => context.utxo.datum && predicate(context.utxo.datum, context) ? label : void 0;
+var tagByScriptRef = (label, options = {}) => ({ utxo }) => {
+  if (!utxo.scriptRef) return void 0;
+  if (options.type && utxo.scriptRef.type !== options.type) {
+    return void 0;
+  }
+  if (options.hash && utxo.scriptRef.hash !== options.hash) {
+    return void 0;
+  }
+  return label;
+};
+var tagChange = (label, options) => {
+  const addresses = new Set(
+    [options.changeAddress, options.walletAddress].filter(
+      (address) => typeof address === "string"
+    )
+  );
+  for (const utxo of options.knownWalletUtxos ?? []) {
+    addresses.add(utxo.address);
+  }
+  const knownOutRefs = new Set(
+    (options.knownWalletUtxos ?? []).map((utxo) => outRefKey(utxo))
+  );
+  return ({ direction, utxo }) => {
+    if (direction === "output" && addresses.has(utxo.address)) return label;
+    if (direction === "input" && knownOutRefs.has(outRefKey(utxo))) {
+      return label;
+    }
+    return void 0;
+  };
+};
+var credentialEquals = (left, right) => left?.type === right.type && left.hash === right.hash;
+
+// src/render/json.ts
+var traceToJSON = (trace) => ({
+  version: 1,
+  ...trace.createdAt ? { createdAt: trace.createdAt } : {},
+  transactions: trace.transactions.map(jsonClone2),
+  utxos: Object.fromEntries(
+    Object.entries(trace.utxos).sort(([left], [right]) => left.localeCompare(right)).map(([key, utxo]) => [key, jsonClone2(utxo)])
+  ),
+  edges: sortedEdges(trace.edges),
+  warnings: trace.warnings.map(jsonClone2),
+  aliases: {
+    assets: sortRecord2(trace.aliases.assets),
+    addresses: sortRecord2(trace.aliases.addresses)
+  }
+});
+var sortRecord2 = (record) => Object.fromEntries(
+  Object.entries(record).sort(([left], [right]) => left.localeCompare(right))
+);
+var jsonClone2 = (value) => JSON.parse(JSON.stringify(value));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildSemanticRenderGraph,
+  createResolutionCache,
+  createTxGraph,
+  describeRedeemerByConstructor,
+  describeRedeemerWith,
+  genesisUtxo,
+  labelRedeemer,
+  outRefKey,
+  parseOutRefKey,
+  parseTransaction,
+  parseTransactionCbor,
+  producedUtxosFromTransaction,
+  resolveVisualRendererOptions,
+  semanticSvgForTesting,
+  tagByAddress,
+  tagByCredential,
+  tagByDatum,
+  tagByDatumHash,
+  tagByPolicyId,
+  tagByScriptRef,
+  tagByUnit,
+  tagChange,
+  toTraceTxOutput,
+  toTraceUtxo,
+  traceToDot,
+  traceToHtml,
+  traceToJSON,
+  traceToMermaid,
+  traceToSvg,
+  unresolvedUtxo,
+  visualEdgeStyle,
+  wrapProvider
+});
+//# sourceMappingURL=index.cjs.map