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

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
+};

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

@@ -0,0 +1,202 @@
+import {
+  applyMemberAdditions,
+  canonicalizeSourceBodies,
+  findContainer,
+  normalizeKind,
+  normalizeMemberText,
+  parseMembers,
+  uniqueStrings
+} from './js-ts-semantic-merge-parse.js';
+import { mergeResult } from './js-ts-safe-member-merge-result.js';
+
+const NonSemanticRegionKinds = new Set(['property', 'type', 'config', 'content']);
+const OrderSensitiveRegionKinds = new Set(['body', 'call', 'controlFlow', 'effect', 'import', 'mutation', 'route']);
+
+function safeMergeJsTsMembers(input = {}) {
+  return mergeJsTsSafeMemberAdditions(input);
+}
+
+function mergeJsTsSafeMemberAdditions(input = {}) {
+  const baseSourceText = input.baseSourceText;
+  const workerSourceText = input.workerSourceText;
+  const headSourceText = input.headSourceText;
+  const reasonCodes = [];
+  if (typeof baseSourceText !== 'string') reasonCodes.push('missing-base-source-text');
+  if (typeof workerSourceText !== 'string') reasonCodes.push('missing-worker-source-text');
+  if (typeof headSourceText !== 'string') reasonCodes.push('missing-head-source-text');
+  const policyRegions = normalizePolicyRegions(input.policy ?? input.mergePolicy ?? input);
+  if (!policyRegions.length) reasonCodes.push('missing-unordered-region-policy');
+  const preparedRegions = [];
+  for (const region of policyRegions) {
+    const policyReasons = validatePolicyRegion(region);
+    reasonCodes.push(...policyReasons);
+    if (policyReasons.length) continue;
+    if (typeof baseSourceText !== 'string' || typeof workerSourceText !== 'string' || typeof headSourceText !== 'string') continue;
+    const prepared = prepareRegion({ region, baseSourceText, workerSourceText, headSourceText });
+    reasonCodes.push(...prepared.reasonCodes);
+    if (prepared.ok) preparedRegions.push(prepared.value);
+  }
+  if (typeof baseSourceText === 'string' && typeof workerSourceText === 'string' && preparedRegions.length) {
+    const canonicalWorker = canonicalizeSourceBodies(workerSourceText, preparedRegions, 'worker');
+    if (canonicalWorker !== baseSourceText) reasonCodes.push('non-policy-source-change:worker');
+  }
+  if (typeof baseSourceText === 'string' && typeof headSourceText === 'string' && preparedRegions.length) {
+    const canonicalHead = canonicalizeSourceBodies(headSourceText, preparedRegions, 'head');
+    if (canonicalHead !== baseSourceText) reasonCodes.push('non-policy-source-change:head');
+  }
+  const uniqueReasons = uniqueStrings(reasonCodes);
+  const explicitPolicy = policyRegions.length > 0;
+  if (uniqueReasons.length) return mergeResult('rejected', undefined, uniqueReasons, preparedRegions, input, explicitPolicy);
+  const sourceText = applyMemberAdditions(headSourceText, preparedRegions);
+  return mergeResult('merged', sourceText, [], preparedRegions, input, explicitPolicy);
+}
+
+function normalizePolicyRegions(policy) {
+  const direct = Array.isArray(policy) ? policy : undefined;
+  const regions = direct
+    ?? policy?.unorderedRegions
+    ?? policy?.unorderedMemberRegions
+    ?? policy?.safeList
+    ?? policy?.safeMembers
+    ?? [];
+  return Array.isArray(regions) ? regions : [];
+}
+
+function validatePolicyRegion(region) {
+  const reasonCodes = [];
+  const kind = normalizeKind(region?.kind);
+  if (!kind || !['interface', 'type', 'class', 'object'].includes(kind)) reasonCodes.push('unsupported-region-kind');
+  if (!region?.name || typeof region.name !== 'string') reasonCodes.push('missing-region-name');
+  if (!regionDeclaresNonSemanticOrder(region)) reasonCodes.push('region-not-declared-non-semantic');
+  const regionKind = region?.regionKind;
+  if (regionKind && OrderSensitiveRegionKinds.has(regionKind)) reasonCodes.push(`order-sensitive-region-kind:${regionKind}`);
+  if (kind === 'object' && (!regionKind || !NonSemanticRegionKinds.has(regionKind))) reasonCodes.push('object-region-kind-not-safe-listed');
+  return reasonCodes;
+}
+
+function regionDeclaresNonSemanticOrder(region) {
+  return region?.order === 'non-semantic'
+    || region?.ordering === 'non-semantic'
+    || region?.nonSemanticOrder === true
+    || region?.orderSensitive === false;
+}
+
+function prepareRegion(input) {
+  const kind = normalizeKind(input.region.kind);
+  const base = findContainer(input.baseSourceText, input.region);
+  const worker = findContainer(input.workerSourceText, input.region);
+  const head = findContainer(input.headSourceText, input.region);
+  const reasonCodes = [];
+  for (const [side, match] of [['base', base], ['worker', worker], ['head', head]]) {
+    if (match.reasonCodes.length) reasonCodes.push(...match.reasonCodes.map((reason) => `${reason}:${side}:${kind}:${input.region.name}`));
+  }
+  if (reasonCodes.length) return { ok: false, reasonCodes };
+  const baseMembers = parseMembers(base.value.body, kind);
+  const workerMembers = parseMembers(worker.value.body, kind);
+  const headMembers = parseMembers(head.value.body, kind);
+  reasonCodes.push(...regionParseReasons(input.region, 'base', baseMembers));
+  reasonCodes.push(...regionParseReasons(input.region, 'worker', workerMembers));
+  reasonCodes.push(...regionParseReasons(input.region, 'head', headMembers));
+  reasonCodes.push(...duplicateReasons(input.region, 'base', baseMembers.members));
+  reasonCodes.push(...duplicateReasons(input.region, 'worker', workerMembers.members));
+  reasonCodes.push(...duplicateReasons(input.region, 'head', headMembers.members));
+  if (reasonCodes.length) return { ok: false, reasonCodes };
+  const baseByKey = membersByKey(baseMembers.members);
+  const workerByKey = membersByKey(workerMembers.members);
+  const headByKey = membersByKey(headMembers.members);
+  reasonCodes.push(...existingMemberReasons(input.region, 'worker', baseMembers.members, workerMembers.members, workerByKey));
+  reasonCodes.push(...existingMemberReasons(input.region, 'head', baseMembers.members, headMembers.members, headByKey));
+  const workerAddedKeys = workerMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
+  const headAddedKeys = headMembers.members.map((member) => member.key).filter((key) => !baseByKey.has(key));
+  reasonCodes.push(...duplicateAddedReasons(input.region, workerAddedKeys, workerByKey, headByKey));
+  if (reasonCodes.length) return { ok: false, reasonCodes };
+  return {
+    ok: true,
+    reasonCodes: [],
+    value: {
+      policy: input.region,
+      kind,
+      name: input.region.name,
+      base: base.value,
+      worker: worker.value,
+      head: head.value,
+      baseMembers: baseMembers.members,
+      workerMembers: workerMembers.members,
+      headMembers: headMembers.members,
+      workerAddedKeys,
+      headAddedKeys,
+      workerAddedMembers: workerMembers.members.filter((member) => workerAddedKeys.includes(member.key))
+    }
+  };
+}
+
+function regionParseReasons(region, side, parsed) {
+  return parsed.reasonCodes.map((reason) => regionReason(region, `${reason}:${side}`));
+}
+
+function duplicateReasons(region, side, members) {
+  const seen = new Map();
+  const duplicateGroups = new Map();
+  for (const member of members) {
+    const group = seen.get(member.key);
+    if (group) {
+      group.push(member);
+      duplicateGroups.set(member.key, group);
+    } else {
+      seen.set(member.key, [member]);
+    }
+  }
+  return [...duplicateGroups].map(([key, group]) => {
+    const reason = group.some(isOverloadLikeMember) ? `overload-collision:${side}:${key}` : `duplicate-key:${side}:${key}`;
+    return regionReason(region, reason);
+  });
+}
+
+function existingMemberReasons(region, side, baseMembers, sideMembers, sideByKey) {
+  const reasonCodes = [];
+  const sideBaseOrder = sideMembers.map((member) => member.key).filter((key) => baseMembers.some((baseMember) => baseMember.key === key));
+  const baseOrder = baseMembers.map((member) => member.key);
+  if (sideBaseOrder.join('\u0000') !== baseOrder.join('\u0000')) {
+    reasonCodes.push(regionReason(region, `existing-member-order-changed:${side}`));
+  }
+  for (const baseMember of baseMembers) {
+    const sideMember = sideByKey.get(baseMember.key);
+    if (!sideMember) {
+      reasonCodes.push(regionReason(region, `existing-member-removed:${side}:${baseMember.key}`));
+      continue;
+    }
+    if (normalizeMemberText(sideMember.text) !== normalizeMemberText(baseMember.text)) {
+      reasonCodes.push(regionReason(region, `existing-member-changed:${side}:${baseMember.key}`));
+    }
+  }
+  return reasonCodes;
+}
+
+function duplicateAddedReasons(region, workerAddedKeys, workerByKey, headByKey) {
+  const duplicateAddedKeys = workerAddedKeys.filter((key) => headByKey.has(key));
+  return duplicateAddedKeys.map((key) => {
+    const workerMember = workerByKey.get(key);
+    const headMember = headByKey.get(key);
+    const reason = isOverloadLikeMember(workerMember) || isOverloadLikeMember(headMember)
+      ? `overload-collision:worker-head:${key}`
+      : `duplicate-added-key:${key}`;
+    return regionReason(region, reason);
+  });
+}
+
+function isOverloadLikeMember(member) {
+  return member?.memberKind === 'method' || member?.memberKind === 'constructor';
+}
+
+function membersByKey(members) {
+  return new Map(members.map((member) => [member.key, member]));
+}
+
+function regionReason(region, reason) {
+  return `${reason}:${normalizeKind(region.kind)}:${region.name}`;
+}
+
+export {
+  mergeJsTsSafeMemberAdditions,
+  safeMergeJsTsMembers
+};