@shapeshift-labs/frontier-lang-compiler 0.2.102 → 0.2.104

package/dist/js-ts-semantic-conflict-sidecar-utils.js

@@ -0,0 +1,190 @@
+import { uniqueStrings } from './native-import-utils.js';
+import { deleteChangeKinds, modifyChangeKinds, riskRank, severityRank } from './js-ts-semantic-conflict-sidecar-constants.js';
+
+export function changePairs(changes) {
+  const pairs = [];
+  for (let leftIndex = 0; leftIndex < changes.length; leftIndex += 1) {
+    for (let rightIndex = leftIndex + 1; rightIndex < changes.length; rightIndex += 1) {
+      pairs.push([changes[leftIndex], changes[rightIndex]]);
+    }
+  }
+  return pairs;
+}
+
+export function duplicateGroups(entries, keyFn) {
+  const groups = new Map();
+  for (const entry of entries) {
+    const key = keyFn(entry);
+    if (!key || /^(\|)+$/.test(key)) continue;
+    groups.set(key, [...(groups.get(key) ?? []), entry]);
+  }
+  return [...groups.values()].filter((group) => group.length > 1);
+}
+
+export function dedupeSidecars(records) {
+  const seen = new Set();
+  const result = [];
+  for (const record of records) {
+    const key = `${record.class}:${record.id}:${record.reasonCodes.join('|')}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(record);
+  }
+  return result.sort(compareSidecars);
+}
+
+function compareSidecars(left, right) {
+  return (riskRank[right.risk] ?? 2) - (riskRank[left.risk] ?? 2)
+    || (severityRank[right.severity] ?? 2) - (severityRank[left.severity] ?? 2)
+    || String(left.class).localeCompare(String(right.class))
+    || String(left.id).localeCompare(String(right.id));
+}
+
+export function mergeContext(input, options) {
+  return {
+    language: options.language ?? input.language ?? input.sourceLanguage ?? 'typescript',
+    sourcePath: options.sourcePath ?? input.sourcePath ?? input.path,
+    readiness: options.readiness ?? input.readiness,
+    expectedSourceHash: firstString(
+      options.expectedSourceHash,
+      input.expectedSourceHash,
+      input.expectedHash,
+      input.sourceHashAssertions?.expectedSourceHash,
+      input.sourceHashes?.expectedSourceHash
+    ),
+    currentSourceHash: firstString(
+      options.currentSourceHash,
+      input.currentSourceHash,
+      input.actualSourceHash,
+      input.sourceHashAssertions?.currentSourceHash,
+      input.sourceHashes?.currentSourceHash
+    )
+  };
+}
+
+export function keysForChange(change) {
+  return uniqueStrings([
+    change.key,
+    change.conflictKey,
+    change.regionKey,
+    change.semanticKey,
+    change.anchorKey
+  ]);
+}
+
+export function keysForAffected(entry) {
+  return uniqueStrings([
+    entry.key,
+    entry.conflictKey,
+    entry.regionKey,
+    entry.semanticKey,
+    entry.anchorKey,
+    entry.containerKey,
+    entry.id
+  ]);
+}
+
+export function lossText(entry) {
+  return [
+    entry?.kind,
+    entry?.code,
+    entry?.reasonCode,
+    ...(entry?.reasonCodes ?? []),
+    entry?.message,
+    entry?.summary,
+    entry?.category,
+    entry?.lossClass
+  ].filter(Boolean).join(' ');
+}
+
+export function lossReasonCodes(entry) {
+  return uniqueStrings([
+    ...strings(entry?.reasonCode),
+    ...strings(entry?.reasonCodes),
+    entry?.code,
+    entry?.kind
+  ]);
+}
+
+export function classesFromRecords(records) {
+  return records.map((record) => record.class);
+}
+
+export function summarySuggestedOutcome(records, readiness) {
+  if (!records.length) return 'auto-merge-safe';
+  const outcomes = uniqueStrings(records.map((record) => record.suggestedOutcome));
+  if (readiness === 'blocked') return outcomes.includes('rerun-parser-and-ledger-before-merge')
+    ? 'rerun-parser-and-ledger-before-merge'
+    : 'manual-merge-required';
+  return outcomes[0] ?? 'human-review';
+}
+
+export function highestSeverity(records) {
+  const value = Math.max(0, ...records.map((record) => severityRank[record.severity] ?? 2));
+  return Object.keys(severityRank).find((severity) => severityRank[severity] === value) ?? 'info';
+}
+
+export function highestRisk(records) {
+  const value = Math.max(0, ...records.map((record) => riskRank[record.risk] ?? 2));
+  return Object.keys(riskRank).find((risk) => riskRank[risk] === value) ?? 'low';
+}
+
+export function normalizeSeverity(value) {
+  const severity = String(value ?? '').toLowerCase();
+  return Object.prototype.hasOwnProperty.call(severityRank, severity) ? severity : undefined;
+}
+
+export function normalizeRisk(value) {
+  const risk = String(value ?? '').toLowerCase();
+  return Object.prototype.hasOwnProperty.call(riskRank, risk) ? risk : undefined;
+}
+
+export function normalizeChangeKind(value) {
+  const text = String(value ?? 'modify').toLowerCase();
+  if (text === 'removed') return 'delete';
+  if (text === 'added') return 'insert';
+  if (text === 'updated') return 'modify';
+  return text;
+}
+
+export function isDeleteChange(change) {
+  return deleteChangeKinds.test(change.changeKind);
+}
+
+export function isModifyChange(change) {
+  return modifyChangeKinds.test(change.changeKind);
+}
+
+export function isInsertChange(change) {
+  return /^(?:insert|add|create)$/i.test(change.changeKind);
+}
+
+export function numberValue(...values) {
+  for (const value of values) {
+    const number = Number(value);
+    if (Number.isFinite(number)) return number;
+  }
+  return undefined;
+}
+
+export function numberOrUndefined(value) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : undefined;
+}
+
+export function array(value) {
+  if (value === undefined || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+export function strings(value) {
+  return array(value).flatMap((entry) => Array.isArray(entry) ? strings(entry) : [String(entry ?? '')]).filter(Boolean);
+}
+
+export function firstString(...values) {
+  return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean);
+}
+
+export function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && entry !== ''));
+}

package/dist/js-ts-semantic-conflict-sidecars.js

@@ -0,0 +1,81 @@
+import { countBy, idFragment, maxSemanticMergeReadiness, normalizeSemanticMergeReadiness, uniqueStrings } from './native-import-utils.js';
+import { JsTsSemanticConflictSidecarClasses } from './js-ts-semantic-conflict-sidecar-constants.js';
+import { deleteModifySidecars, duplicateDeclarationSidecars, explicitSidecars, orderedListSidecars, parserLedgerLossSidecars, sameRegionSidecars, staleSourceHashSidecars, unsupportedSyntaxSidecars } from './js-ts-semantic-conflict-sidecar-detectors.js';
+import { normalizedChanges } from './js-ts-semantic-conflict-sidecar-normalize.js';
+import { array, classesFromRecords, compactRecord, dedupeSidecars, highestRisk, highestSeverity, mergeContext, summarySuggestedOutcome } from './js-ts-semantic-conflict-sidecar-utils.js';
+
+export { JsTsSemanticConflictSidecarClasses } from './js-ts-semantic-conflict-sidecar-constants.js';
+
+export function createJsTsSemanticConflictSidecars(input = {}, options = {}) {
+  const context = mergeContext(input, options);
+  const changes = normalizedChanges(input, context);
+  const records = dedupeSidecars([
+    ...explicitSidecars(input, context),
+    ...sameRegionSidecars(changes, context),
+    ...deleteModifySidecars(changes, context),
+    ...duplicateDeclarationSidecars(input, changes, context),
+    ...orderedListSidecars(input, changes, context),
+    ...parserLedgerLossSidecars(input, context),
+    ...staleSourceHashSidecars(input, context),
+    ...unsupportedSyntaxSidecars(input, context)
+  ]);
+  const summary = summarizeJsTsSemanticConflictSidecars(records, context);
+  const id = options.id
+    ?? input.id
+    ?? `js_ts_semantic_conflict_sidecars_${idFragment(context.sourcePath ?? context.language ?? 'source')}`;
+  return {
+    kind: 'frontier.lang.jsTsSemanticMergeConflictSidecars',
+    version: 1,
+    schema: 'frontier.lang.jsTsSemanticMergeConflictSidecars.v1',
+    id,
+    language: context.language,
+    sourcePath: context.sourcePath,
+    expectedSourceHash: context.expectedSourceHash,
+    currentSourceHash: context.currentSourceHash,
+    conflicts: records,
+    sidecars: records,
+    summary,
+    admission: {
+      status: records.length ? summary.readiness : 'ready',
+      reviewRequired: records.length > 0,
+      autoMergeSafe: records.length === 0,
+      suggestedOutcome: summary.suggestedOutcome,
+      reasonCodes: summary.reasonCodes
+    },
+    metadata: compactRecord({
+      conflictSidecarSource: 'js-ts-semantic-merge',
+      ...options.metadata,
+      ...input.metadata
+    })
+  };
+}
+
+export function summarizeJsTsSemanticConflictSidecars(records = [], context = {}) {
+  const list = array(records).filter(Boolean);
+  const classes = uniqueStrings(list.map((record) => record.class));
+  const reasonCodes = uniqueStrings(list.flatMap((record) => record.reasonCodes ?? []));
+  const affectedSourcePaths = uniqueStrings([
+    context.sourcePath,
+    ...list.flatMap((record) => record.affected?.sourcePaths ?? [])
+  ]);
+  const affectedKeys = uniqueStrings(list.flatMap((record) => record.affected?.keys ?? []));
+  const readiness = list.reduce(
+    (current, record) => maxSemanticMergeReadiness(current, record.readiness ?? 'needs-review'),
+    normalizeSemanticMergeReadiness(context.readiness) ?? 'ready'
+  );
+  return {
+    schema: 'frontier.lang.jsTsSemanticConflictSidecarSummary.v1',
+    total: list.length,
+    classes,
+    byClass: countBy(classesFromRecords(list)),
+    bySeverity: countBy(list.map((record) => record.severity ?? 'warning')),
+    byRisk: countBy(list.map((record) => record.risk ?? 'medium')),
+    highestSeverity: highestSeverity(list),
+    highestRisk: highestRisk(list),
+    readiness,
+    affectedSourcePaths,
+    affectedKeys,
+    reasonCodes,
+    suggestedOutcome: summarySuggestedOutcome(list, readiness)
+  };
+}

package/dist/js-ts-semantic-merge-contract-helpers.js

@@ -0,0 +1,128 @@
+import { idFragment, normalizeSemanticMergeReadiness, uniqueStrings } from './native-import-utils.js';
+import { JsTsSemanticMergeGateStatuses } from './js-ts-semantic-merge-contracts.js';
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+
+export function normalizeConflictSides(sides = {}) {
+  return compactRecord({
+    base: normalizeConflictSide('base', sides.base),
+    left: normalizeConflictSide('left', sides.left),
+    right: normalizeConflictSide('right', sides.right)
+  });
+}
+
+function normalizeConflictSide(side, value) {
+  if (!value) return undefined;
+  return compactRecord({
+    side: firstString(value.side, side),
+    sourcePath: firstString(value.sourcePath),
+    sourceHash: firstString(value.sourceHash),
+    editIds: uniqueStrings(value.editIds),
+    regionIds: uniqueStrings(value.regionIds),
+    tokenIds: uniqueStrings(value.tokenIds),
+    summary: firstString(value.summary),
+    metadata: value.metadata
+  });
+}
+
+export function normalizeGateChecks(checks, fallbackStatus) {
+  return array(checks).filter(Boolean).map((check, index) => {
+    const status = normalizeGateStatus(check.status) ?? fallbackStatus;
+    const name = firstString(check.name, check.id, `check-${index + 1}`);
+    const reasonCodes = uniqueStrings([
+      ...strings(check.reasonCodes),
+      ...strings(check.reasons),
+      ...(status === 'passed' ? [] : [`js-ts-merge-check:${status}`])
+    ]);
+    const stablePayload = compactRecord({
+      name,
+      status,
+      readiness: normalizeSemanticMergeReadiness(check.readiness) ?? check.readiness,
+      reasonCodes,
+      evidenceIds: uniqueStrings(check.evidenceIds)
+    });
+    const hash = firstString(check.hash) || hashSemanticValue(stablePayload);
+    return compactRecord({
+      id: firstString(check.id) || `js_ts_merge_check_${idFragment(name)}_${idFragment(hash)}`,
+      name,
+      status,
+      readiness: stablePayload.readiness,
+      reasonCodes,
+      evidenceIds: stablePayload.evidenceIds,
+      hash,
+      metadata: check.metadata
+    });
+  });
+}
+
+export function readinessForRisk(risk) {
+  if (risk === 'high') return 'blocked';
+  if (risk === 'low') return 'ready-with-losses';
+  return 'needs-review';
+}
+
+export function readinessForGateStatus(status, checks, conflictExplanationIds) {
+  if (status === 'blocked' || status === 'failed') return 'blocked';
+  if (conflictExplanationIds.length > 0) return 'needs-review';
+  if (checks.some((check) => check.status === 'failed' || check.status === 'blocked')) return 'blocked';
+  if (status === 'warning' || checks.some((check) => check.status === 'warning')) return 'ready-with-losses';
+  if (status === 'passed') return 'ready';
+  return 'needs-review';
+}
+
+export function actionForConflict({ risk, readiness }) {
+  if (readiness === 'blocked' || risk === 'high') return 'block';
+  if (readiness === 'ready') return 'merge';
+  return 'manual-review';
+}
+
+export function actionForGate({ status, readiness, mergeable }) {
+  if (mergeable) return 'merge';
+  if (status === 'blocked' || status === 'failed' || readiness === 'blocked') return 'block';
+  if (status === 'skipped') return 'skip';
+  return 'review';
+}
+
+export function titleForConflictClass(conflictClass) {
+  return String(conflictClass).split(/[-_]+/g).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' ');
+}
+
+export function normalizeRisk(value) {
+  const risk = String(value ?? '').toLowerCase();
+  return risk === 'low' || risk === 'medium' || risk === 'high' ? risk : undefined;
+}
+
+export function normalizeGateStatus(value) {
+  const status = String(value ?? '').toLowerCase();
+  return JsTsSemanticMergeGateStatuses.includes(status) ? status : undefined;
+}
+
+export function booleanValue(...values) {
+  for (const value of values) {
+    if (typeof value === 'boolean') return value;
+  }
+  return undefined;
+}
+
+export function numberValue(...values) {
+  for (const value of values) {
+    if (typeof value === 'number' && Number.isFinite(value)) return value;
+  }
+  return undefined;
+}
+
+export function array(value) {
+  if (value === undefined || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+export function strings(value) {
+  return array(value).map((entry) => entry === undefined || entry === null ? '' : String(entry)).filter(Boolean);
+}
+
+export function firstString(...values) {
+  return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean);
+}
+
+export function compactRecord(value) {
+  return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined));
+}

package/dist/js-ts-semantic-merge-contracts.js

@@ -0,0 +1,217 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, normalizeSemanticMergeReadiness, uniqueStrings } from './native-import-utils.js';
+
+export const JsTsSemanticMergeConflictClasses = Object.freeze([
+  'same-token-edit',
+  'same-region-edit',
+  'delete-modify',
+  'move-edit',
+  'rename-rename',
+  'import-order',
+  'type-surface-drift',
+  'trivia-preservation',
+  'behavior-evidence-needed'
+]);
+
+export const JsTsSemanticMergeGateStatuses = Object.freeze([
+  'passed',
+  'warning',
+  'failed',
+  'skipped',
+  'blocked'
+]);
+
+import { actionForConflict, actionForGate, array, booleanValue, compactRecord, firstString, normalizeConflictSides, normalizeGateChecks, normalizeGateStatus, normalizeRisk, numberValue, readinessForGateStatus, readinessForRisk, strings, titleForConflictClass } from './js-ts-semantic-merge-contract-helpers.js';
+
+export function createJsTsSemanticMergeConflictExplanation(input = {}, options = {}) {
+  const conflictClass = firstString(options.conflictClass, input.conflictClass, input.class, 'same-region-edit');
+  const risk = normalizeRisk(firstString(options.risk, input.risk, input.severity)) ?? 'medium';
+  const readiness = normalizeSemanticMergeReadiness(firstString(options.readiness, input.readiness)) ?? readinessForRisk(risk);
+  const language = firstString(options.language, input.language);
+  const sourcePath = firstString(options.sourcePath, input.sourcePath);
+  const conflictKeys = uniqueStrings([
+    ...strings(input.conflictKeys),
+    input.conflictKey,
+    ...strings(options.conflictKeys),
+    options.conflictKey
+  ]);
+  const matchIds = uniqueStrings([...strings(input.matchIds), ...strings(options.matchIds)]);
+  const editIds = uniqueStrings([...strings(input.editIds), ...strings(options.editIds)]);
+  const regionIds = uniqueStrings([...strings(input.regionIds), ...strings(options.regionIds)]);
+  const tokenIds = uniqueStrings([...strings(input.tokenIds), ...strings(options.tokenIds)]);
+  const triviaIds = uniqueStrings([...strings(input.triviaIds), ...strings(options.triviaIds)]);
+  const evidenceIds = uniqueStrings([...strings(input.evidenceIds), ...strings(options.evidenceIds)]);
+  const reasonCodes = uniqueStrings([
+    ...strings(input.reasonCodes),
+    ...strings(input.reasons),
+    ...strings(options.reasonCodes),
+    `js-ts-conflict:${conflictClass}`
+  ]);
+  const sides = normalizeConflictSides(options.sides ?? input.sides);
+  const title = firstString(options.title, input.title, titleForConflictClass(conflictClass));
+  const summary = firstString(options.summary, input.summary, input.message);
+  const suggestedAction = firstString(options.suggestedAction, input.suggestedAction, actionForConflict({ risk, readiness }));
+  const stablePayload = compactRecord({
+    schema: 'frontier.lang.jsTsSemanticMergeConflictExplanation.v1',
+    conflictClass,
+    risk,
+    readiness,
+    language,
+    sourcePath,
+    title,
+    summary,
+    conflictKeys,
+    matchIds,
+    editIds,
+    regionIds,
+    tokenIds,
+    triviaIds,
+    evidenceIds,
+    reasonCodes,
+    sides,
+    suggestedAction
+  });
+  const hash = hashSemanticValue(stablePayload);
+  const stableId = firstString(options.stableId, input.stableId)
+    || `js_ts_merge_conflict_${idFragment(firstString(conflictKeys[0], sourcePath, conflictClass))}_${idFragment(hash)}`;
+  return compactRecord({
+    kind: 'frontier.lang.jsTsSemanticMergeConflictExplanation',
+    version: 1,
+    schema: 'frontier.lang.jsTsSemanticMergeConflictExplanation.v1',
+    id: firstString(options.id, input.id, stableId),
+    stableId,
+    hash,
+    conflictClass,
+    risk,
+    readiness,
+    language,
+    sourcePath,
+    title,
+    summary,
+    conflictKeys,
+    matchIds,
+    editIds,
+    regionIds,
+    tokenIds,
+    triviaIds,
+    evidenceIds,
+    reasonCodes,
+    sides,
+    suggestedAction,
+    metadata: compactRecord({
+      normalizedBy: 'frontier-lang-compiler/js-ts-semantic-merge',
+      structuralContract: true,
+      ...(input.metadata ?? {}),
+      ...(options.metadata ?? {})
+    })
+  });
+}
+
+export function createJsTsSemanticMergeGateResult(input = {}, options = {}) {
+  const gateId = firstString(options.gateId, input.gateId, input.id, 'js-ts-semantic-merge');
+  const status = normalizeGateStatus(firstString(options.status, input.status)) ?? 'skipped';
+  const conflicts = [
+    ...array(input.conflictExplanations),
+    ...array(input.conflicts),
+    ...array(options.conflictExplanations),
+    ...array(options.conflicts)
+  ].filter(Boolean).map((conflict) => createJsTsSemanticMergeConflictExplanation(conflict));
+  const conflictExplanationIds = uniqueStrings([
+    ...strings(input.conflictExplanationIds),
+    ...strings(options.conflictExplanationIds),
+    ...conflicts.map((conflict) => conflict.id)
+  ]);
+  const checks = normalizeGateChecks([
+    ...array(input.checks),
+    ...array(options.checks)
+  ], status);
+  const readiness = normalizeSemanticMergeReadiness(firstString(options.readiness, input.readiness)) ?? readinessForGateStatus(status, checks, conflictExplanationIds);
+  const evidenceIds = uniqueStrings([
+    ...strings(input.evidenceIds),
+    ...strings(options.evidenceIds),
+    ...checks.flatMap((check) => strings(check.evidenceIds)),
+    ...conflicts.flatMap((conflict) => conflict.evidenceIds)
+  ]);
+  const reasonCodes = uniqueStrings([
+    ...strings(input.reasonCodes),
+    ...strings(options.reasonCodes),
+    ...checks.flatMap((check) => strings(check.reasonCodes)),
+    ...conflicts.flatMap((conflict) => conflict.reasonCodes),
+    ...(status === 'passed' ? [] : [`js-ts-merge-gate:${status}`])
+  ]);
+  const structuredEditIds = uniqueStrings([
+    ...strings(input.structuredEditIds),
+    ...strings(options.structuredEditIds),
+    ...array(input.structuredEdits).map((edit) => edit?.id),
+    ...array(options.structuredEdits).map((edit) => edit?.id)
+  ]);
+  const semanticRegionIds = uniqueStrings([
+    ...strings(input.semanticRegionIds),
+    ...strings(options.semanticRegionIds),
+    ...array(input.semanticRegions).map((region) => region?.id),
+    ...array(options.semanticRegions).map((region) => region?.id)
+  ]);
+  const mergeable = booleanValue(options.mergeable, input.mergeable)
+    ?? (status === 'passed' && readiness === 'ready' && conflictExplanationIds.length === 0);
+  const action = firstString(options.action, input.action, actionForGate({ status, readiness, mergeable }));
+  const confidence = numberValue(options.confidence, input.confidence, status === 'passed' ? 1 : 0);
+  const failedChecks = checks.filter((check) => check.status === 'failed').length;
+  const warningChecks = checks.filter((check) => check.status === 'warning').length;
+  const blockedChecks = checks.filter((check) => check.status === 'blocked').length;
+  const summary = {
+    checks: checks.length,
+    conflicts: conflictExplanationIds.length,
+    failedChecks,
+    warningChecks,
+    blockedChecks,
+    evidenceIds: evidenceIds.length,
+    reasonCodes
+  };
+  const stablePayload = compactRecord({
+    schema: 'frontier.lang.jsTsSemanticMergeGateResult.v1',
+    gateId,
+    status,
+    readiness,
+    mergeable,
+    action,
+    confidence,
+    checks,
+    conflictExplanationIds,
+    structuredEditIds,
+    semanticRegionIds,
+    evidenceIds,
+    reasonCodes,
+    summary
+  });
+  const hash = hashSemanticValue(stablePayload);
+  const stableId = firstString(options.stableId, input.stableId)
+    || `js_ts_merge_gate_${idFragment(gateId)}_${idFragment(hash)}`;
+  return compactRecord({
+    kind: 'frontier.lang.jsTsSemanticMergeGateResult',
+    version: 1,
+    schema: 'frontier.lang.jsTsSemanticMergeGateResult.v1',
+    id: firstString(options.id, input.id, stableId),
+    stableId,
+    hash,
+    gateId,
+    status,
+    readiness,
+    mergeable,
+    action,
+    confidence,
+    checks,
+    conflictExplanations: conflicts,
+    conflictExplanationIds,
+    structuredEditIds,
+    semanticRegionIds,
+    evidenceIds,
+    reasonCodes,
+    summary,
+    metadata: compactRecord({
+      normalizedBy: 'frontier-lang-compiler/js-ts-semantic-merge',
+      structuralContract: true,
+      ...(input.metadata ?? {}),
+      ...(options.metadata ?? {})
+    })
+  });
+}