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

package/dist/internal/index-impl/semanticPatchBundleSourceRecords.js

@@ -102,6 +102,8 @@ export function normalizeSourceMapLinks(links) {
       precision: link.precision,
       sourceSpan: link.sourceSpan,
       generatedSpan: link.generatedSpan,
+      sourceReplacementText: link.sourceReplacementText,
+      sourceReplacementTextHash: link.sourceReplacementTextHash,
       regionKey: link.ownershipRegionKey,
       regionKind: link.ownershipRegionKind
     }));

package/dist/internal/index-impl/semanticSidecarQuality.js

@@ -0,0 +1,111 @@
+import { uniqueStrings } from '../../native-import-utils.js';
+
+function summarizeSemanticSidecarQuality(sources) {
+  const records = uniqueSemanticSidecarQualityRecords(array(sources).flatMap(semanticSidecarQualityRecords));
+  const warningCodes = uniqueStrings(records.flatMap(sidecarQualityWarningCodes));
+  const zeroRecordWarningCodes = uniqueStrings(records.flatMap(sidecarQualityZeroRecordWarningCodes));
+  return {
+    records: records.length,
+    symbols: records.reduce((sum, record) => sum + sidecarQualityCount(record, 'symbolCount', 'symbols'), 0),
+    ownershipRegions: records.reduce((sum, record) => sum + sidecarQualityCount(record, 'ownershipRegionCount', 'ownershipRegions'), 0),
+    patchHints: records.reduce((sum, record) => sum + sidecarQualityCount(record, 'patchHintCount', 'patchHints'), 0),
+    warnings: records.reduce((sum, record) => sum + sidecarQualityWarningCount(record), 0),
+    zeroRecordWarnings: zeroRecordWarningCodes.length,
+    warningCodes,
+    zeroRecordWarningCodes
+  };
+}
+
+function semanticSidecarQualityRecords(source) {
+  if (!source || typeof source !== 'object') return [];
+  return [
+    source.semanticSidecarQuality,
+    source.sidecarQuality,
+    source.semanticSidecar?.quality,
+    source.sidecar?.quality,
+    source.semanticSidecarAdmission,
+    source.sidecarAdmission,
+    source.semanticSidecar?.admission,
+    source.sidecar?.admission,
+    source.metadata?.semanticSidecarQuality,
+    source.metadata?.sidecarQuality,
+    source.metadata?.semanticSidecarAdmission,
+    source.metadata?.sidecarAdmission
+  ].filter(looksLikeSemanticSidecarQuality);
+}
+
+function looksLikeSemanticSidecarQuality(value) {
+  return value && typeof value === 'object' && (
+    value.schema === 'frontier.lang.semanticSidecarQuality.v1' ||
+    value.schema === 'frontier.lang.semanticSidecarAdmission.v1' ||
+    value.imported !== undefined ||
+    value.eligible !== undefined ||
+    value.expectedSatisfied !== undefined ||
+    value.warningCount !== undefined ||
+    value.emptyEvidenceWarnings !== undefined ||
+    value.proofSummary !== undefined ||
+    value.counts !== undefined
+  );
+}
+
+function uniqueSemanticSidecarQualityRecords(records) {
+  const seen = new Set();
+  const result = [];
+  for (const record of records) {
+    const key = record.id ?? JSON.stringify({
+      schema: record.schema,
+      symbols: sidecarQualityCount(record, 'symbolCount', 'symbols'),
+      ownershipRegions: sidecarQualityCount(record, 'ownershipRegionCount', 'ownershipRegions'),
+      patchHints: sidecarQualityCount(record, 'patchHintCount', 'patchHints'),
+      warningCodes: sidecarQualityWarningCodes(record)
+    });
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(record);
+  }
+  return result;
+}
+
+function sidecarQualityCount(record, field, countsField) {
+  for (const value of [record?.[field], record?.counts?.[countsField]]) {
+    const count = Number(value ?? 0);
+    if (Number.isFinite(count) && count > 0) return count;
+  }
+  return 0;
+}
+
+function sidecarQualityWarningCount(record) {
+  const count = Number(record?.warningCount ?? 0);
+  if (Number.isFinite(count) && count > 0) return count;
+  return sidecarQualityWarningCodes(record).length;
+}
+
+function sidecarQualityWarningCodes(record) {
+  return uniqueStrings([
+    ...array(record?.warnings).map((warning) => warning?.code ?? warning?.reasonCode),
+    ...array(record?.emptyEvidenceWarnings).map((warning) => warning?.code ?? warning?.reasonCode),
+    ...strings(record?.expectedMissingReasonCodes),
+    ...strings(record?.reasonCodes)
+  ].filter(Boolean));
+}
+
+function sidecarQualityZeroRecordWarningCodes(record) {
+  return sidecarQualityWarningCodes(record).filter(isZeroRecordWarningCode);
+}
+
+function isZeroRecordWarningCode(code) {
+  return [
+    'empty-evidence',
+    'empty-semantic-index',
+    'expected-semantic-import-empty',
+    'expected-semantic-import-missing',
+    'missing-imports',
+    'missing-ownership-regions',
+    'missing-patch-hints'
+  ].includes(code);
+}
+
+function array(value) { if (value === undefined || value === null) return []; return Array.isArray(value) ? value : [value]; }
+function strings(value) { return array(value).map((entry) => String(entry ?? '')).filter(Boolean); }
+
+export { summarizeSemanticSidecarQuality };

package/dist/internal/index-impl/semanticSourceEditDedupe.js

@@ -8,11 +8,18 @@ export function applySourceEdits(sourceText, edits) {
 }
 
 export function dedupeSourceEdits(edits) {
-  const exact = dedupeExactInsertions(edits);
-  const covered = removeCoveredContainerReplacements(exact.edits);
+  const exact = dedupeExactEdits(edits);
+  const noops = removeNoopReplacements(exact.edits);
+  const coveredDeletes = removeContainedDeletionEdits(noops.edits);
+  const covered = removeCoveredContainerReplacements(coveredDeletes.edits);
   return {
     edits: covered.edits,
-    skippedOperationIds: [...exact.skippedOperationIds, ...covered.skippedOperationIds]
+    skippedOperationIds: [
+      ...exact.skippedOperationIds,
+      ...noops.skippedOperationIds,
+      ...coveredDeletes.skippedOperationIds,
+      ...covered.skippedOperationIds
+    ]
   };
 }
 
@@ -27,7 +34,7 @@ export function validateSourceEdits(edits) {
   return uniqueStrings(reasons);
 }
 
-function dedupeExactInsertions(edits) {
+function dedupeExactEdits(edits) {
   const seen = new Map();
   const result = [];
   const skippedOperationIds = [];
@@ -43,6 +50,19 @@ function dedupeExactInsertions(edits) {
   return { edits: result, skippedOperationIds };
 }
 
+function removeNoopReplacements(edits) {
+  const skippedOperationIds = [];
+  const result = [];
+  for (const edit of edits) {
+    if (edit.editKind === 'replace' && !edit.alreadyApplied && edit.current === edit.replacement) {
+      skippedOperationIds.push(edit.operationId);
+      continue;
+    }
+    result.push(edit);
+  }
+  return { edits: result, skippedOperationIds };
+}
+
 function removeCoveredContainerReplacements(edits) {
   const skippedOperationIds = [];
   const result = [];
@@ -56,6 +76,31 @@ function removeCoveredContainerReplacements(edits) {
   return { edits: result, skippedOperationIds };
 }
 
+function removeContainedDeletionEdits(edits) {
+  const skippedOperationIds = [];
+  const result = [];
+  for (const edit of edits) {
+    if (deleteCoveredByLargerDelete(edit, edits)) {
+      skippedOperationIds.push(edit.operationId);
+      continue;
+    }
+    result.push(edit);
+  }
+  return { edits: result, skippedOperationIds };
+}
+
+function deleteCoveredByLargerDelete(edit, edits) {
+  return edit.editKind === 'delete' && !edit.alreadyApplied && edits.some((candidate) => (
+    candidate !== edit &&
+    candidate.editKind === 'delete' &&
+    !candidate.alreadyApplied &&
+    sameSourcePath(candidate, edit) &&
+    candidate.start <= edit.start &&
+    edit.end <= candidate.end &&
+    (candidate.start !== edit.start || candidate.end !== edit.end)
+  ));
+}
+
 function containerReplacementCoveredByInsertions(edit, edits) {
   if (edit.editKind !== 'replace' || edit.alreadyApplied) return false;
   const insertions = containedInsertions(edit, edits);
@@ -76,15 +121,30 @@ function containedInsertions(container, edits) {
     .sort((left, right) => left.start - right.start || (left.order ?? 0) - (right.order ?? 0));
 }
 
+function sameSourcePath(left, right) {
+  const leftPath = left.targetSourcePath ?? left.sourcePath;
+  const rightPath = right.targetSourcePath ?? right.sourcePath;
+  return !leftPath || !rightPath || leftPath === rightPath;
+}
+
 function duplicateEditKey(edit) {
-  if (edit.editKind !== 'insert') return undefined;
+  if (edit.alreadyApplied) return undefined;
+  if (edit.editKind === 'insert') {
+    return [
+      'insert',
+      edit.start,
+      edit.end,
+      edit.insertion?.mode,
+      edit.insertion?.anchorKey,
+      hashSemanticValue(edit.replacementSpanText ?? edit.replacement)
+    ].join(':');
+  }
   return [
-    'insert',
+    edit.editKind,
     edit.start,
     edit.end,
-    edit.insertion?.mode,
-    edit.insertion?.anchorKey,
-    hashSemanticValue(edit.replacementSpanText ?? edit.replacement)
+    hashSemanticValue(edit.current),
+    hashSemanticValue(edit.replacement)
   ].join(':');
 }
 

package/dist/internal/index-impl/semanticTransformIdentityRecords.js

@@ -4,7 +4,7 @@ import { semanticEditIdentityFields } from './semanticEditIdentityRecords.js';
 
 export function createSemanticTransformIdentityRecord(input = {}, options = {}) {
   const source = input?.transform ?? input;
-  const merged = { ...source, ...options };
+  const merged = { ...source, ...definedEntries(options) };
   const editIdentity = semanticEditIdentityFields(merged);
   const semanticKey = firstString(merged.semanticKey, editIdentity.semanticKey);
   const transformKey = firstString(merged.transformKey, semanticTransformKey({ ...merged, semanticKey }));
@@ -32,6 +32,9 @@ export function createSemanticTransformIdentityRecord(input = {}, options = {})
     merged.transformContentHash,
     operationContentHash || editContentHash ? hashSemanticValue(compactRecord({ transformIdentityHash, operationContentHash, editContentHash })) : undefined
   );
+  const sourceMapIds = uniqueStrings([...strings(merged.sourceMapIds), ...strings(merged.sourceMapId), ...strings(merged.metadata?.sourceMapIds), ...strings(merged.metadata?.sourceMapId)]);
+  const sourceMapLinkIds = uniqueStrings([...strings(merged.sourceMapLinkIds), ...strings(merged.sourceMapLinkId), ...strings(merged.metadata?.sourceMapLinkIds), ...strings(merged.metadata?.sourceMapLinkId)]);
+  const sourceMapMappingIds = uniqueStrings([...strings(merged.sourceMapMappingIds), ...strings(merged.sourceMapMappingId), ...strings(merged.metadata?.sourceMapMappingIds), ...strings(merged.metadata?.sourceMapMappingId)]);
   const id = merged.id && source.kind === 'frontier.lang.semanticTransformIdentityRecord'
     ? merged.id
     : firstString(merged.id, `semantic_transform_${idFragment(firstString(transformKey, semanticKey, sourcePath, targetPath, 'record'))}`);
@@ -55,6 +58,9 @@ export function createSemanticTransformIdentityRecord(input = {}, options = {})
     transformIdentityHash,
     projectionIdentityHash,
     transformContentHash,
+    sourceMapIds,
+    sourceMapLinkIds,
+    sourceMapMappingIds,
     readiness: firstString(merged.readiness),
     confidence: typeof merged.confidence === 'number' ? merged.confidence : undefined,
     evidenceIds: uniqueStrings(merged.evidenceIds),
@@ -80,20 +86,29 @@ export function semanticTransformInputs(source = {}, options = {}) {
     ...array(options.semanticEditProjections ?? options.semanticEditProjection),
     ...array(source.semanticEditProjections ?? source.semanticEditProjection)
   ];
+  const scripts = [
+    ...array(options.semanticEditScripts ?? options.semanticEditScript),
+    ...array(source.semanticEditScripts ?? source.semanticEditScript)
+  ];
   return [
     ...array(options.semanticTransformIdentities ?? options.semanticTransformIdentity),
     ...array(source.semanticTransformIdentities ?? source.semanticTransformIdentity ?? source.semanticTransforms),
     ...array(source.index?.semanticTransformIdentities),
-    ...deriveSemanticTransformIdentityRecords({ semanticEditProjections: projections }, { ...source, ...options })
+    ...deriveSemanticTransformIdentityRecords({ semanticEditProjections: projections, semanticEditScripts: scripts }, { ...source, ...options })
   ];
 }
 
 export function deriveSemanticTransformIdentityRecords(input = {}, options = {}) {
   const projections = semanticEditProjectionInputs(input);
-  return uniqueRecords(projections.flatMap((projection, projectionIndex) => {
+  const projectionRecords = projections.flatMap((projection, projectionIndex) => {
     const edits = array(projection.edits).filter((edit) => edit && typeof edit === 'object');
     return edits.map((edit, editIndex) => transformRecordForProjectionEdit(edit, projection, input, options, projectionIndex, editIndex));
-  }));
+  });
+  const scriptRecords = projections.length ? [] : semanticEditScriptInputs(input).flatMap((script, scriptIndex) => {
+    const operations = array(script.operations).filter((operation) => operation && typeof operation === 'object');
+    return operations.map((operation, operationIndex) => transformRecordForScriptOperation(operation, script, input, options, scriptIndex, operationIndex));
+  });
+  return uniqueRecords([...projectionRecords, ...scriptRecords]);
 }
 
 export function semanticTransformRecordIndex(records, source = {}) {
@@ -104,12 +119,18 @@ export function semanticTransformRecordIndex(records, source = {}) {
     semanticTransformIdentityHashes: uniqueStrings([...strings(source.semanticTransformIdentityHashes), ...strings(index.semanticTransformIdentityHashes), ...records.map((record) => record.transformIdentityHash)]),
     semanticTransformContentHashes: uniqueStrings([...strings(source.semanticTransformContentHashes), ...strings(index.semanticTransformContentHashes), ...records.map((record) => record.transformContentHash)]),
     projectionIdentityHashes: uniqueStrings([...strings(source.projectionIdentityHashes), ...strings(index.projectionIdentityHashes), ...records.map((record) => record.projectionIdentityHash)]),
+    transformBaseHashes: uniqueStrings([...strings(source.transformBaseHashes), ...strings(index.transformBaseHashes), ...records.map((record) => record.baseHash)]),
+    transformTargetHashes: uniqueStrings([...strings(source.transformTargetHashes), ...strings(index.transformTargetHashes), ...records.map((record) => record.targetHash)]),
     semanticTransformReadinesses: uniqueStrings([...strings(source.semanticTransformReadinesses), ...strings(index.semanticTransformReadinesses), ...records.map((record) => record.readiness)]),
     semanticTransformEvidenceIds: uniqueStrings([...strings(source.semanticTransformEvidenceIds), ...strings(index.semanticTransformEvidenceIds), ...records.flatMap((record) => record.evidenceIds)]),
     transformSourceLanguages: uniqueStrings([...strings(source.transformSourceLanguages), ...strings(index.transformSourceLanguages), ...records.map((record) => record.sourceLanguage)]),
     transformTargetLanguages: uniqueStrings([...strings(source.transformTargetLanguages), ...strings(index.transformTargetLanguages), ...records.map((record) => record.targetLanguage)]),
     transformSourcePaths: uniqueStrings([...strings(source.transformSourcePaths), ...strings(index.transformSourcePaths), ...records.map((record) => record.sourcePath)]),
-    transformTargetPaths: uniqueStrings([...strings(source.transformTargetPaths), ...strings(index.transformTargetPaths), ...records.map((record) => record.targetPath)])
+    transformTargetPaths: uniqueStrings([...strings(source.transformTargetPaths), ...strings(index.transformTargetPaths), ...records.map((record) => record.targetPath)]),
+    transformCrossLanguages: uniqueStrings([...strings(source.transformCrossLanguages), ...strings(index.transformCrossLanguages), ...records.map(transformCrossLanguageFlag)]),
+    transformSourceMapIds: uniqueStrings([...strings(source.transformSourceMapIds), ...strings(index.transformSourceMapIds), ...records.flatMap((record) => record.sourceMapIds)]),
+    transformSourceMapLinkIds: uniqueStrings([...strings(source.transformSourceMapLinkIds), ...strings(index.transformSourceMapLinkIds), ...records.flatMap((record) => record.sourceMapLinkIds)]),
+    transformSourceMapMappingIds: uniqueStrings([...strings(source.transformSourceMapMappingIds), ...strings(index.transformSourceMapMappingIds), ...records.flatMap((record) => record.sourceMapMappingIds)])
   };
 }
 
@@ -121,14 +142,24 @@ export function semanticTransformSummary(index) {
     identityHashes: index.semanticTransformIdentityHashes,
     contentHashes: index.semanticTransformContentHashes,
     projectionIdentityHashes: index.projectionIdentityHashes,
+    baseHashes: index.transformBaseHashes,
+    targetHashes: index.transformTargetHashes,
     readinesses: index.semanticTransformReadinesses,
     evidenceIds: index.semanticTransformEvidenceIds,
     sourceLanguages: index.transformSourceLanguages,
     targetLanguages: index.transformTargetLanguages,
-    targetPaths: index.transformTargetPaths
+    targetPaths: index.transformTargetPaths,
+    crossLanguages: index.transformCrossLanguages,
+    sourceMapIds: index.transformSourceMapIds,
+    sourceMapLinkIds: index.transformSourceMapLinkIds,
+    sourceMapMappingIds: index.transformSourceMapMappingIds
   });
 }
 
+function transformCrossLanguageFlag(record) {
+  return record.sourceLanguage && record.targetLanguage && record.sourceLanguage !== record.targetLanguage ? 'true' : 'false';
+}
+
 function semanticTransformKey(record) {
   const scope = record.semanticKey ?? (record.symbolName
     ? `${record.symbolKind ?? 'symbol'}:${record.symbolName}`
@@ -145,11 +176,19 @@ function semanticEditProjectionInputs(input) {
   ].filter((entry) => entry && typeof entry === 'object');
 }
 
+function semanticEditScriptInputs(input) {
+  if (input.kind === 'frontier.lang.semanticEditScript') return [input];
+  return [
+    ...array(input.semanticEditScripts ?? input.semanticEditScript),
+    ...array(input.scripts ?? input.script)
+  ].filter((entry) => entry && typeof entry === 'object');
+}
+
 function transformRecordForProjectionEdit(edit, projection, input, options, projectionIndex, editIndex) {
   const sourceLanguage = firstString(edit.sourceLanguage, edit.language, input.sourceLanguage, options.sourceLanguage, projection.sourceLanguage, projection.language);
-  const targetLanguage = firstString(edit.targetLanguage, edit.projectedLanguage, input.targetLanguage, options.targetLanguage, projection.targetLanguage, projection.projectedLanguage, projection.language);
+  const targetLanguage = firstString(edit.targetLanguage, edit.projectedLanguage, input.targetLanguage, options.targetLanguage, projection.metadata?.targetLanguage, projection.targetLanguage, projection.projectedLanguage, projection.language);
   const sourcePath = firstString(edit.originalSourcePath, edit.sourcePath, input.sourcePath, options.sourcePath, projection.sourcePath);
-  const targetPath = firstString(edit.targetPath, edit.targetSourcePath, input.targetPath, options.targetPath, projection.targetPath, projection.projectedSourcePath, projection.sourcePath);
+  const targetPath = firstString(edit.targetPath, edit.targetSourcePath, input.targetPath, options.targetPath, projection.metadata?.targetPath, projection.targetPath, projection.projectedSourcePath, projection.sourcePath);
   const transformId = [projection.id, edit.operationId, projectionIndex, editIndex].filter((entry) => entry !== undefined && entry !== null).join(':');
   return createSemanticTransformIdentityRecord(edit, {
     id: `semantic_transform_${idFragment(transformId)}`,
@@ -158,7 +197,10 @@ function transformRecordForProjectionEdit(edit, projection, input, options, proj
     sourcePath,
     targetPath,
     baseHash: firstString(edit.baseHash, projection.baseHash, input.baseHash, options.baseHash),
-    targetHash: firstString(edit.targetHash, projection.projectedHash, projection.targetHash, input.targetHash, options.targetHash),
+    targetHash: firstString(edit.targetHash, projection.metadata?.targetHash, projection.projectedHash, projection.targetHash, input.targetHash, options.targetHash),
+    sourceMapIds: projection.metadata?.sourceMapIds,
+    sourceMapLinkIds: projection.metadata?.sourceMapLinkIds,
+    sourceMapMappingIds: projection.metadata?.sourceMapMappingIds,
     readiness: firstString(edit.readiness, projection.admission?.status, projection.status),
     evidenceIds: uniqueStrings([...strings(input.evidenceIds), ...strings(options.evidenceIds), ...strings(projection.evidenceIds), ...strings(edit.evidenceIds)]),
     metadata: compactRecord({
@@ -168,6 +210,39 @@ function transformRecordForProjectionEdit(edit, projection, input, options, proj
   });
 }
 
+function transformRecordForScriptOperation(operation, script, input, options, scriptIndex, operationIndex) {
+  const targetRegion = operation.metadata?.targetRegion ?? {};
+  const transformId = [script.id, operation.id, scriptIndex, operationIndex].filter((entry) => entry !== undefined && entry !== null).join(':');
+  return createSemanticTransformIdentityRecord(operation, {
+    id: `semantic_transform_${idFragment(transformId)}`,
+    sourceLanguage: firstString(operation.anchor?.language, script.language, input.sourceLanguage, options.sourceLanguage),
+    targetLanguage: firstString(targetRegion.language, script.metadata?.targetLanguage, input.targetLanguage, options.targetLanguage),
+    sourcePath: firstString(operation.anchor?.sourcePath, script.sourcePath, input.sourcePath, options.sourcePath),
+    targetPath: firstString(targetRegion.sourcePath, script.metadata?.targetPath, input.targetPath, options.targetPath),
+    baseHash: firstString(operation.hashes?.baseSourceHash, script.baseHash, input.baseHash, options.baseHash),
+    targetHash: firstString(targetRegion.sourceHash, operation.hashes?.workerSourceHash, input.targetHash, options.targetHash),
+    sourceMapIds: script.metadata?.sourceProjectionHint?.sourceMapIds,
+    sourceMapLinkIds: operation.metadata?.sourceMapLinkIds,
+    sourceMapMappingIds: operation.metadata?.sourceMapMappingIds,
+    readiness: firstString(script.admission?.status, script.metadata?.sourceProjectionHint?.status),
+    evidenceIds: uniqueStrings([
+      ...strings(input.evidenceIds),
+      ...strings(options.evidenceIds),
+      ...array(script.evidence).map((record) => record?.id),
+      ...strings(operation.evidenceIds)
+    ]),
+    metadata: compactRecord({
+      sourceEditScriptId: script.id,
+      sourceEditOperationId: operation.id,
+      sourceProjectionHintId: script.metadata?.sourceProjectionHint?.id,
+      sourceMapIds: script.metadata?.sourceProjectionHint?.sourceMapIds,
+      sourceMapLinkIds: operation.metadata?.sourceMapLinkIds,
+      sourceMapMappingIds: operation.metadata?.sourceMapMappingIds,
+      reviewOnly: script.admission?.reviewRequired === true
+    })
+  });
+}
+
 function uniqueRecords(records) {
   const seen = new Set();
   const result = [];
@@ -184,4 +259,5 @@ function array(value) { if (value === undefined || value === null) return []; re
 function strings(value) { return array(value).map((entry) => String(entry ?? '')).filter(Boolean); }
 function firstString(...values) { return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean); }
 function uniqueStrings(values) { return uniqueRawStrings((values ?? []).filter((entry) => entry !== undefined && entry !== null && String(entry) !== '')); }
+function definedEntries(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined)); }
 function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

package/dist/js-ts-safe-member-merge-result.js

@@ -0,0 +1,158 @@
+import {
+  JsTsSafeMergeConflictCodes,
+  JsTsSafeMergeGateIds,
+  jsTsSafeMergeGateOrder
+} from './js-ts-safe-merge-constants.js';
+import { uniqueStrings } from './js-ts-semantic-merge-parse.js';
+
+function mergeResult(status, sourceText, reasonCodes, regions, input, explicitPolicy) {
+  const conflicts = status === 'merged'
+    ? []
+    : reasonCodes.map((reason, index) => memberConflictForReason(reason, input, index));
+  const mergedRegions = regions.map((region) => ({
+    kind: region.kind,
+    name: region.name,
+    regionKind: region.policy.regionKind,
+    workerAddedKeys: region.workerAddedKeys,
+    headAddedKeys: region.headAddedKeys
+  }));
+  return {
+    kind: 'frontier.lang.jsTsSafeMemberMerge',
+    version: 1,
+    status,
+    sourceText,
+    reasonCodes,
+    conflicts,
+    gates: memberGates(conflicts),
+    admission: memberAdmission(status, conflicts),
+    mergedRegions,
+    summary: {
+      regions: mergedRegions.length,
+      workerAdditions: mergedRegions.reduce((total, region) => total + region.workerAddedKeys.length, 0),
+      headAdditions: mergedRegions.reduce((total, region) => total + region.headAddedKeys.length, 0),
+      appliedAdditions: status === 'merged' ? mergedRegions.reduce((total, region) => total + region.workerAddedKeys.length, 0) : 0,
+      conflicts: conflicts.length
+    },
+    metadata: { explicitPolicy }
+  };
+}
+
+function memberAdmission(status, conflicts) {
+  const reasonCodes = uniqueStrings(conflicts.map((conflict) => conflict.details.reasonCode ?? conflict.code));
+  if (status === 'merged') {
+    return {
+      status: 'auto-merge-candidate',
+      action: 'apply',
+      reviewRequired: false,
+      autoApplyCandidate: true,
+      reasonCodes: []
+    };
+  }
+  return {
+    status: 'blocked',
+    action: 'human-review',
+    reviewRequired: true,
+    autoApplyCandidate: false,
+    reasonCodes
+  };
+}
+
+function memberGates(conflicts) {
+  const blockedGateIds = new Set(conflicts.map((conflict) => conflict.gateId));
+  const reasonCodesByGate = new Map();
+  for (const conflict of conflicts) {
+    const gateReasonCodes = reasonCodesByGate.get(conflict.gateId) ?? [];
+    gateReasonCodes.push(conflict.details.reasonCode ?? conflict.code);
+    reasonCodesByGate.set(conflict.gateId, uniqueStrings(gateReasonCodes));
+  }
+  let blockedSeen = false;
+  return jsTsSafeMergeGateOrder.map((id) => {
+    const blocked = blockedGateIds.has(id);
+    const status = blocked ? 'blocked' : blockedSeen ? 'skipped' : 'passed';
+    if (blocked) blockedSeen = true;
+    return { id, status, reasonCodes: reasonCodesByGate.get(id) ?? [] };
+  });
+}
+
+function memberConflictForReason(reason, input, index) {
+  const reasonCode = blockedReasonCode(reason);
+  const code = conflictCodeForReason(reasonCode);
+  const gateId = gateIdForReason(reasonCode);
+  const details = reasonDetails(reason, reasonCode);
+  return {
+    code,
+    gateId,
+    message: memberConflictMessage(reasonCode, details),
+    side: details.side,
+    sourcePath: input.sourcePath,
+    details: { ...details, index }
+  };
+}
+
+function blockedReasonCode(reason) {
+  if (reason.includes('computed-key')) return 'computed-key';
+  if (reason.includes('spread-like-member') || reason.includes('spread-member')) return 'spread-like-member';
+  if (reason.includes('overload-collision')) return 'overload-collision';
+  if (reason.includes('type-alias-conflict')) return 'type-alias-conflict';
+  if (reason.includes('duplicate-added-key') || reason.includes('duplicate-key')) return 'duplicate-member-name';
+  if (reason.includes('existing-member-changed')) return 'changed-existing-member';
+  if (reason.includes('existing-member-removed')) return 'removed-existing-member';
+  if (reason.includes('existing-member-order-changed')) return 'existing-member-order-changed';
+  if (reason.includes('order-sensitive-region-kind')) return 'order-sensitive-region-kind';
+  if (reason.includes('non-policy-source-change')) return 'non-policy-source-change';
+  if (reason.includes('unterminated-container')) return 'malformed-syntax';
+  if (reason.includes('unsupported-')) return 'unsupported-js-ts-syntax';
+  if (reason.includes('missing-') || reason.includes('not-safe-listed') || reason.includes('not-declared')) return 'invalid-input';
+  if (reason.includes('ambiguous-container') || reason.includes('container-not-found')) return 'parser-or-ledger-loss';
+  return reason.split(':')[0] || 'member-merge-blocked';
+}
+
+function conflictCodeForReason(reasonCode) {
+  if (reasonCode === 'computed-key') return JsTsSafeMergeConflictCodes.computedKey;
+  if (reasonCode === 'overload-collision') return JsTsSafeMergeConflictCodes.unsupportedOverload;
+  if (reasonCode === 'type-alias-conflict') return JsTsSafeMergeConflictCodes.typeAliasConflict;
+  if (reasonCode === 'duplicate-member-name') return JsTsSafeMergeConflictCodes.duplicateName;
+  if (reasonCode === 'changed-existing-member' || reasonCode === 'removed-existing-member' || reasonCode === 'non-policy-source-change') {
+    return JsTsSafeMergeConflictCodes.changedExistingDeclaration;
+  }
+  if (reasonCode === 'existing-member-order-changed' || reasonCode === 'order-sensitive-region-kind') return JsTsSafeMergeConflictCodes.topLevelOrderChanged;
+  if (reasonCode === 'malformed-syntax') return JsTsSafeMergeConflictCodes.malformedSyntax;
+  if (reasonCode === 'invalid-input') return JsTsSafeMergeConflictCodes.invalidInput;
+  return JsTsSafeMergeConflictCodes.parserLedgerLoss;
+}
+
+function gateIdForReason(reasonCode) {
+  if (reasonCode === 'duplicate-member-name' || reasonCode === 'overload-collision') return JsTsSafeMergeGateIds.uniqueNames;
+  if (reasonCode === 'changed-existing-member' || reasonCode === 'removed-existing-member' || reasonCode === 'non-policy-source-change') {
+    return JsTsSafeMergeGateIds.stableExistingDeclarations;
+  }
+  if (reasonCode === 'existing-member-order-changed' || reasonCode === 'order-sensitive-region-kind') return JsTsSafeMergeGateIds.preserveBaseOrder;
+  return JsTsSafeMergeGateIds.parseLedger;
+}
+
+function reasonDetails(reason, reasonCode) {
+  const parts = String(reason).split(':');
+  const details = { reason, reasonCode };
+  if (['base', 'worker', 'head'].includes(parts[1])) details.side = parts[1];
+  if (['base', 'worker', 'head'].includes(parts[2])) details.side = parts[2];
+  const kind = parts.find((part) => ['interface', 'type', 'class', 'object'].includes(part));
+  if (kind) details.regionKind = kind;
+  if (reasonCode === 'duplicate-member-name' || reasonCode === 'overload-collision') details.memberName = parts.at(-3) ?? parts.at(-1);
+  if (reasonCode === 'changed-existing-member' || reasonCode === 'removed-existing-member') details.memberName = parts.at(-3);
+  return details;
+}
+
+function memberConflictMessage(reasonCode, details) {
+  if (reasonCode === 'computed-key') return 'Computed member keys are not safe for automatic member merge.';
+  if (reasonCode === 'spread-like-member') return 'Spread-like member syntax makes object member merge ambiguous.';
+  if (reasonCode === 'overload-collision') return 'Member overloads or duplicate method signatures collide in an unordered member region.';
+  if (reasonCode === 'changed-existing-member') return 'An existing member changed inside a safe member-addition region.';
+  if (reasonCode === 'removed-existing-member') return 'An existing member was removed inside a safe member-addition region.';
+  if (reasonCode === 'duplicate-member-name') return 'Worker and head member additions contain the same member key.';
+  if (reasonCode === 'existing-member-order-changed') return 'A side changed the order of existing members in a non-semantic member region.';
+  return `JS/TS member merge blocked: ${details.reason}`;
+}
+
+export {
+  mergeResult
+};