@shapeshift-labs/frontier-lang-compiler 0.2.150 → 0.2.151

package/dist/js-ts-safe-merge-variable-declarator-fallback.js

@@ -16,8 +16,13 @@ function createVariableDeclaratorSemanticFallbackResult(input, topLevelResult, s
     headSourceText: input.headSourceText,
     currentSourceText
   });
-  if (!merge.ok || merge.sourceText === currentSourceText) return undefined;
   const resultBase = stagedFallback?.stagedTopLevelResult ?? topLevelResult;
+  if (!merge.ok) {
+    return merge.sourceShapeBlocked
+      ? variableDeclaratorBlockedResult(input, topLevelResult, resultBase, stagedFallback, merge)
+      : undefined;
+  }
+  if (merge.sourceText === currentSourceText) return undefined;
   const language = input.language ?? topLevelResult.language ?? 'typescript';
   const sourcePath = input.sourcePath ?? topLevelResult.sourcePath ?? 'inline.ts';
   const phase = stagedFallback
@@ -142,17 +147,28 @@ function mergeVariableStatement(base, worker, head, current) {
     const workerDeclarator = worker.declarators[index];
     const headDeclarator = head.declarators[index];
     const currentDeclarator = current.declarators[index];
-    if (![workerDeclarator, headDeclarator, currentDeclarator].every((entry) => entry?.name === baseDeclarator.name)) {
-      return blockedStatement('variable-declarator-name-order-changed');
+    const bindingPatternReasonCodes = classifyDeclaratorBindingPattern(baseDeclarator, workerDeclarator, headDeclarator, currentDeclarator);
+    if (bindingPatternReasonCodes.length) return blockedStatement(...bindingPatternReasonCodes);
+    if (![workerDeclarator, headDeclarator, currentDeclarator].every((entry) => entry?.key === baseDeclarator.key)) {
+      return blockedStatement(
+        ...declaratorKeyChangeReasonCodes(baseDeclarator, workerDeclarator, headDeclarator, currentDeclarator),
+        'variable-declarator-name-order-changed'
+      );
     }
     const workerChanged = !sameVariableDeclaratorText(baseDeclarator.text, workerDeclarator.text);
     const headChanged = !sameVariableDeclaratorText(baseDeclarator.text, headDeclarator.text);
     if (workerChanged && headChanged && !sameVariableDeclaratorText(workerDeclarator.text, headDeclarator.text)) {
-      return blockedStatement('variable-declarator-conflict');
+      return blockedStatement(
+        ...bindingDeclaratorConflictReasonCodes(baseDeclarator),
+        'variable-declarator-conflict'
+      );
     }
     if (!sameVariableDeclaratorText(currentDeclarator.text, headDeclarator.text)
       && !sameVariableDeclaratorText(currentDeclarator.text, workerDeclarator.text)) {
-      return blockedStatement('variable-declarator-current-diverged');
+      return blockedStatement(
+        ...bindingDeclaratorConflictReasonCodes(baseDeclarator),
+        'variable-declarator-current-diverged'
+      );
     }
     const replacement = workerChanged ? workerDeclarator.text : currentDeclarator.text;
     if (!sameVariableDeclaratorText(replacement, currentDeclarator.text)) changed = true;
@@ -164,6 +180,46 @@ function mergeVariableStatement(base, worker, head, current) {
   };
 }
 
+function classifyDeclaratorBindingPattern(base, worker, head, current) {
+  const declarators = [base, worker, head, current].filter(Boolean);
+  if (!declarators.some((entry) => entry.binding?.kind === 'binding-pattern')) return [];
+  const reasonCodes = uniqueStrings(declarators.flatMap((entry) => entry.binding?.reasonCodes ?? []));
+  if (reasonCodes.length) return reasonCodes;
+  if (!declarators.every((entry) => entry.binding?.kind === base.binding?.kind && entry.binding?.patternKind === base.binding?.patternKind)) {
+    return [
+      'binding-pattern-kind-changed',
+      'binding-pattern-merge-requires-binding-use-evidence'
+    ];
+  }
+  const patternTexts = declarators.map((entry) => entry.binding?.patternText);
+  if (patternTexts.some((text) => !sameVariableDeclaratorText(text, patternTexts[0]))) {
+    return [
+      'binding-pattern-shape-changed',
+      'binding-pattern-merge-requires-binding-use-evidence'
+    ];
+  }
+  const bindingNames = declarators.map((entry) => (entry.binding?.bindingNames ?? []).join('\0'));
+  if (bindingNames.some((names) => names !== bindingNames[0])) {
+    return [
+      'binding-pattern-binding-set-changed',
+      'binding-pattern-merge-requires-binding-use-evidence'
+    ];
+  }
+  return [];
+}
+
+function declaratorKeyChangeReasonCodes(base, worker, head, current) {
+  return [base, worker, head, current].some((entry) => entry?.binding?.kind === 'binding-pattern')
+    ? ['binding-pattern-kind-changed', 'binding-pattern-merge-requires-binding-use-evidence']
+    : [];
+}
+
+function bindingDeclaratorConflictReasonCodes(base) {
+  return base?.binding?.kind === 'binding-pattern'
+    ? ['binding-pattern-merge-requires-binding-use-evidence']
+    : [];
+}
+
 function semanticArtifactGates(artifacts) {
   return [
     gate('semantic-edit-script', artifacts.script?.admission?.status === 'auto-merge-candidate', artifacts.script?.admission?.reasonCodes),
@@ -177,8 +233,70 @@ function gate(id, passed, reasonCodes = []) {
   return { id, status: passed ? 'passed' : 'blocked', reasonCodes: passed ? [] : uniqueStrings(reasonCodes) };
 }
 
+function variableDeclaratorBlockedResult(input, topLevelResult, resultBase, stagedFallback, merge) {
+  const reasonCodes = merge.reasonCodes;
+  const language = input.language ?? topLevelResult.language ?? 'typescript';
+  const sourcePath = input.sourcePath ?? topLevelResult.sourcePath ?? 'inline.ts';
+  return {
+    ...resultBase,
+    id: String(input.id ?? resultBase.id ?? topLevelResult.id),
+    status: JsTsSafeMergeStatuses.blocked,
+    mergedSourceText: undefined,
+    outputSourceText: undefined,
+    conflicts: [{
+      code: reasonCodes[0] ?? 'binding-pattern-merge-blocked',
+      gateId: 'variable-declarator-binding-pattern',
+      message: 'JS/TS variable declarator binding pattern requires binding/use evidence before automatic merge.',
+      side: 'worker',
+      sourcePath,
+      details: {
+        reasonCodes,
+        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? []
+      }
+    }],
+    admission: {
+      status: 'blocked',
+      action: 'human-review',
+      reviewRequired: true,
+      autoApplyCandidate: false,
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false,
+      reasonCodes
+    },
+    summary: {
+      ...resultBase.summary,
+      changedExistingDeclarations: semanticFallbackChangedExistingDeclarations(topLevelResult, resultBase, stagedFallback),
+      conflicts: 1,
+      variableDeclaratorBindingPatternBlocks: 1,
+      composedPhases: stagedFallback ? 2 : 1
+    },
+    metadata: {
+      ...resultBase.metadata,
+      composed: {
+        phase: stagedFallback
+          ? 'staged-top-level-variable-declarator-binding-pattern-classification'
+          : 'variable-declarator-binding-pattern-classification',
+        phases: stagedFallback
+          ? ['top-level-neutralization', 'top-level-ledger', 'variable-declarator-binding-pattern']
+          : ['top-level-ledger', 'variable-declarator-binding-pattern'],
+        originalReasonCodes: topLevelResult.admission?.reasonCodes ?? [],
+        stagedTopLevelSummary: stagedFallback?.stagedTopLevelResult?.summary,
+        neutralization: stagedFallback?.neutralization?.summary,
+        variableDeclaratorFallback: merge.summary,
+        language
+      }
+    }
+  };
+}
+
 function blocked(...reasonCodes) {
-  return { ok: false, reasonCodes: uniqueStrings(reasonCodes) };
+  const normalized = uniqueStrings(reasonCodes);
+  return {
+    ok: false,
+    reasonCodes: normalized,
+    sourceShapeBlocked: normalized.some((reasonCode) => reasonCode.startsWith('binding-pattern-')),
+    summary: { reasonCodes: normalized }
+  };
 }
 
 function blockedStatement(...reasonCodes) {

package/dist/js-ts-safe-merge-variable-declarator-parser.js

@@ -1,3 +1,7 @@
+import {
+  analyzeJsTsBindingPattern,
+  leadingJsTsBindingPatternText
+} from './js-ts-safe-merge-binding-patterns.js';
 import { normalizeLineEndings, uniqueStrings } from './js-ts-safe-merge-context.js';
 
 function variableStatementsByKey(sourceText) {
@@ -27,14 +31,14 @@ function parseVariableStatement(statement) {
   const declaratorText = text.slice(prefixEnd, suffixStart);
   if (/[\r\n]/.test(declaratorText)) return undefined;
   const declarators = splitDeclarators(declaratorText, prefixEnd);
-  if (declarators.length < 2 || declarators.some((entry) => !entry.name)) return undefined;
+  if (declarators.length < 2 || declarators.some((entry) => !entry.key)) return undefined;
   return {
     start: statement.start,
     end: statement.end,
     text,
     prefix: text.slice(0, prefixEnd),
     suffix: text.slice(suffixStart),
-    names: declarators.map((entry) => entry.name),
+    names: declarators.map((entry) => entry.key),
     declarators
   };
 }
@@ -104,15 +108,41 @@ function declaratorPart(text, start, end, offset) {
   while (localStart < localEnd && /\s/u.test(text[localStart])) localStart += 1;
   while (localEnd > localStart && /\s/u.test(text[localEnd - 1])) localEnd -= 1;
   const value = text.slice(localStart, localEnd);
-  const name = /^[A-Za-z_$][\w$]*/u.exec(value)?.[0];
+  const binding = declaratorBinding(value);
   return {
-    name: name && value[name.length] !== '?' ? name : undefined,
+    name: binding?.name,
+    key: binding?.key,
+    binding,
     text: value,
     start: offset + localStart,
     end: offset + localEnd
   };
 }
 
+function declaratorBinding(value) {
+  const identifier = /^[A-Za-z_$][\w$]*/u.exec(value)?.[0];
+  if (identifier && value[identifier.length] !== '?') {
+    return { kind: 'identifier', patternKind: 'identifier', name: identifier, key: identifier, reasonCodes: [] };
+  }
+  let start = 0;
+  while (start < value.length && /\s/u.test(value[start])) start += 1;
+  const open = value[start];
+  if (open !== '{' && open !== '[') return undefined;
+  const patternKind = open === '{' ? 'object' : 'array';
+  const patternText = leadingJsTsBindingPatternText(value.slice(start), patternKind);
+  if (!patternText) return undefined;
+  const pattern = analyzeJsTsBindingPattern(patternText, patternKind);
+  return {
+    kind: 'binding-pattern',
+    patternKind: pattern.patternKind,
+    name: `binding-pattern:${pattern.patternKind}`,
+    key: `binding-pattern:${pattern.patternKind}`,
+    patternText,
+    bindingNames: pattern.bindingNames,
+    reasonCodes: pattern.reasonCodes
+  };
+}
+
 function topLevelStatements(sourceText) {
   const statements = [];
   let start = 0;

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

@@ -12,6 +12,9 @@ import { createJsTsSafeMergeSemanticArtifacts } from './js-ts-safe-merge-semanti
 
 export { JsTsSafeMergeConflictCodes, JsTsSafeMergeGateIds, JsTsSafeMergeStatuses };
 
+const mergedOutputSyntaxDiagnosticCode = 'merged-output-syntax-diagnostic';
+const mergedOutputSyntaxDiagnosticsUnavailableCode = 'merged-output-syntax-diagnostics-unavailable';
+
 export function safeMergeJsTsImportsAndDeclarations(input = {}) {
   const context = createMergeContext(input);
   const baseSourceText = input.baseSourceText;
@@ -60,6 +63,7 @@ export function safeMergeJsTsImportsAndDeclarations(input = {}) {
   const mergedSourceText = applySourceMergePlan(headSourceText, mergePlan);
   const merged = scanJsTsTopLevelLedger(mergedSourceText, 'merged', context);
   if (!context.conflicts.length) validateLedgerUniqueness(merged, context);
+  if (!context.conflicts.length) validateMergedOutputSyntaxGate(input, context);
   if (context.conflicts.length) return blockedResult(context, { base, worker, head, merged });
 
   const result = {
@@ -179,3 +183,135 @@ function hasLedgerSpan(entry) {
   const hasLines = Number.isFinite(span.startLine) && Number.isFinite(span.endLine);
   return hasOffsets || hasLines;
 }
+
+function validateMergedOutputSyntaxGate(input, context) {
+  const diagnostics = normalizeMergedOutputSyntaxDiagnostics(input, context.sourcePath);
+  if (!diagnostics) {
+    if (requiresMergedOutputSyntaxDiagnostics(input)) {
+      addConflict(context, {
+        code: mergedOutputSyntaxDiagnosticsUnavailableCode,
+        gateId: JsTsSafeMergeGateIds.parseLedger,
+        side: 'merged',
+        message: 'Merged JS/TS output syntax diagnostics are required but were not provided.',
+        details: { required: true, diagnosticSource: 'missing' }
+      });
+    }
+    return;
+  }
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.severity !== 'error' || !isSyntaxDiagnostic(diagnostic)) continue;
+    addConflict(context, {
+      code: mergedOutputSyntaxDiagnosticCode,
+      gateId: JsTsSafeMergeGateIds.parseLedger,
+      side: 'merged',
+      message: `Merged JS/TS output syntax diagnostic ${diagnostic.code}: ${diagnostic.message}`,
+      details: { diagnostic }
+    });
+  }
+}
+
+function requiresMergedOutputSyntaxDiagnostics(input) {
+  return input.requireMergedOutputSyntaxDiagnostics === true
+    || input.requireOutputSyntaxDiagnostics === true
+    || input.requireOutputSyntaxGate === true
+    || input.requireSyntaxGate === true;
+}
+
+function normalizeMergedOutputSyntaxDiagnostics(input, sourcePath) {
+  const values = [
+    input.mergedOutputSyntaxDiagnostics,
+    input.outputSyntaxDiagnostics,
+    input.syntaxDiagnostics?.merged,
+    input.syntaxDiagnostics?.output,
+    input.outputDiagnostics
+  ];
+  if (!values.some((value) => value !== undefined)) return undefined;
+  const expectedPath = normalizeDiagnosticPath(sourcePath);
+  const diagnostics = values
+    .flatMap((value) => normalizeDiagnosticList(value))
+    .filter((diagnostic) => {
+      const diagnosticPath = normalizeDiagnosticPath(diagnostic.sourcePath);
+      return !expectedPath || !diagnosticPath || expectedPath === diagnosticPath;
+    });
+  return diagnostics;
+}
+
+function normalizeDiagnosticList(value) {
+  if (value === undefined) return [];
+  const values = Array.isArray(value) ? value : [value].filter(Boolean);
+  return values.map((diagnostic, index) => compactRecord({
+    id: diagnostic.id ?? `diagnostic_${index + 1}`,
+    source: diagnostic.source ?? diagnostic.tool ?? diagnostic.name,
+    code: String(diagnostic.code ?? diagnostic.diagnosticCode ?? diagnostic.name ?? 'syntax-diagnostic'),
+    severity: normalizeDiagnosticSeverity(diagnostic.severity ?? diagnostic.category),
+    message: String(diagnostic.message ?? diagnostic.messageText ?? ''),
+    sourcePath: normalizeDiagnosticPath(diagnostic.sourcePath ?? diagnostic.fileName ?? diagnostic.file?.fileName),
+    start: numberOrUndefined(diagnostic.start),
+    end: numberOrUndefined(diagnostic.end),
+    line: numberOrUndefined(diagnostic.line),
+    column: numberOrUndefined(diagnostic.column),
+    phase: normalizeDiagnosticPhase(diagnostic.phase ?? diagnostic.diagnosticPhase ?? diagnostic.kind ?? diagnostic.type),
+    syntax: diagnostic.syntax === true ? true : undefined
+  }));
+}
+
+function isSyntaxDiagnostic(diagnostic) {
+  if (diagnostic.syntax === true) return true;
+  const text = [
+    diagnostic.phase,
+    diagnostic.kind,
+    diagnostic.category,
+    diagnostic.type,
+    diagnostic.source,
+    diagnostic.ruleId,
+    diagnostic.name,
+    diagnostic.code
+  ].filter(Boolean).join(' ').toLowerCase();
+  return /\bsyntax\b|\bsyntactic\b|\bparse\b|\bparser\b/.test(text) || isTypeScriptSyntaxDiagnosticCode(diagnostic.code);
+}
+
+function isTypeScriptSyntaxDiagnosticCode(code) {
+  const match = /^TS(\d+)$/.exec(String(code ?? ''));
+  if (!match) return false;
+  const numeric = Number(match[1]);
+  return numeric >= 1000 && numeric < 2000;
+}
+
+function normalizeDiagnosticSeverity(value) {
+  if (typeof value === 'string') {
+    const lowered = value.toLowerCase();
+    if (lowered.includes('error')) return 'error';
+    if (lowered.includes('warn')) return 'warning';
+    if (lowered.includes('suggest')) return 'suggestion';
+    if (lowered.includes('message')) return 'message';
+  }
+  if (value === 1) return 'error';
+  if (value === 0) return 'warning';
+  if (value === 2) return 'suggestion';
+  if (value === 3) return 'message';
+  return 'error';
+}
+
+function normalizeDiagnosticPhase(value) {
+  if (typeof value !== 'string') return undefined;
+  const lowered = value.toLowerCase();
+  if (lowered.includes('syntax') || lowered.includes('syntactic') || lowered.includes('parse')) return 'syntax';
+  if (lowered.includes('semantic') || lowered.includes('type')) return 'semantic';
+  return value;
+}
+
+function normalizeDiagnosticPath(value) {
+  if (value === undefined || value === null) return undefined;
+  const raw = String(value).replace(/\\/g, '/').replace(/\/+/g, '/');
+  const parts = [];
+  for (const part of raw.split('/')) {
+    if (!part || part === '.') continue;
+    if (part === '..' && parts.length) parts.pop();
+    else if (part !== '..') parts.push(part);
+  }
+  return parts.join('/');
+}
+
+function numberOrUndefined(value) {
+  return Number.isFinite(value) ? value : undefined;
+}

package/dist/js-ts-safe-project-merge-admission-routes.js

@@ -0,0 +1,216 @@
+const exactAdmissionRouteSpecs = Object.freeze({
+  'js-ts-project-symbol-rename-admission': routeSpec('apply-cross-file-symbol-rename', 'cross-file-symbol-rename', 'apply-project-symbol-rename'),
+  'js-ts-project-symbol-move-admission': routeSpec('apply-symbol-move-between-files', 'symbol-move-between-files', 'apply-project-symbol-move'),
+  'js-ts-project-split-merge-admission': routeSpec('apply-project-split-merge', 'split-merge-modules-classes', 'apply-project-split-merge')
+});
+
+const classificationRouteSpecs = Object.freeze({
+  'cross-file-symbol-rename': routeSpec('review-cross-file-symbol-rename', 'cross-file-symbol-rename', 'supply-import-export-rewrite-diagnostics-and-declarations'),
+  'exported-symbol-move': routeSpec('review-symbol-move-between-files', 'symbol-move-between-files', 'supply-symbol-lineage-rewrite-diagnostics-and-declarations'),
+  'imported-symbol-move': routeSpec('review-symbol-move-between-files', 'symbol-move-between-files', 'supply-symbol-lineage-rewrite-diagnostics-and-declarations'),
+  'file-move-rename': routeSpec('review-file-move-rename', 'file-move-rename', 'supply-path-lineage-rewrite-diagnostics-and-declarations'),
+  'module-split': routeSpec('review-project-split-merge', 'split-merge-modules-classes', 'supply-structural-partition-diagnostics-and-declarations'),
+  'module-merge': routeSpec('review-project-split-merge', 'split-merge-modules-classes', 'supply-structural-partition-diagnostics-and-declarations'),
+  'class-split': routeSpec('review-project-split-merge', 'split-merge-modules-classes', 'supply-structural-partition-diagnostics-and-declarations'),
+  'class-merge': routeSpec('review-project-split-merge', 'split-merge-modules-classes', 'supply-structural-partition-diagnostics-and-declarations')
+});
+
+function createProjectAdmissionRoutes(input = {}) {
+  return uniqueProjectAdmissionRoutes([
+    ...(input.fileResults ?? []).flatMap(fileAdmissionRoutes),
+    ...(input.missingEvidence ?? []).map(projectAdmissionRouteFromMissingEvidence),
+    ...(input.conflicts ?? []).map(projectAdmissionRouteFromConflict)
+  ].filter(Boolean));
+}
+
+function projectAdmissionRouteSummary(routes = []) {
+  return compactRecord({
+    total: routes.length,
+    byKind: countField(routes, 'routeKind'),
+    byAction: countField(routes, 'action'),
+    byLane: countField(routes, 'routeLane'),
+    byStatus: countField(routes, 'status'),
+    byRoute: countField(routes, 'routeId'),
+    nextRoute: routes.find((route) => route.status !== 'passed') ?? routes[0]
+  });
+}
+
+function projectAdmissionRouteFromExactAdmission(admission, options = {}) {
+  const spec = exactAdmissionRouteSpecs[admission?.kind] ?? routeSpec(`apply-${safeToken(admission?.kind ?? 'project-admission')}`, 'project-admission', options.action ?? 'apply-project');
+  return routeRecord({
+    routeId: spec.routeId,
+    routeKind: 'apply',
+    routeLane: spec.routeLane,
+    routeNext: spec.routeNext,
+    action: 'apply',
+    status: 'passed',
+    source: 'file-admission',
+    subjectKind: admission?.kind,
+    branch: admission?.branch,
+    sourcePath: admission?.sourcePath,
+    sourcePaths: admission?.details?.sourcePaths,
+    evidenceId: admission?.id,
+    conflictKey: admission?.details?.conflictKey,
+    reasonCodes: admission?.details?.reasonCode ? [admission.details.reasonCode] : [],
+    requiredEvidence: admission?.details?.requiredEvidence,
+    presentEvidence: admission?.details?.presentRequiredEvidence,
+    details: admission?.details
+  });
+}
+
+function projectAdmissionRouteFromClassification(classification, options = {}) {
+  const details = classification?.details ?? {};
+  const spec = classificationRouteSpecs[classification?.kind] ?? routeSpec(`review-${safeToken(classification?.kind ?? classification?.code ?? 'project-admission')}`, 'project-admission', 'review-structural-admission-evidence');
+  const explicitRouteId = details.routeId ?? details.proofRouteId;
+  const staleRouteId = details.structuralProofRouteId;
+  const stale = details.staleStructuralEditProof === true || details.otherBranchChanged === true;
+  return routeRecord({
+    routeId: options.routeId ?? explicitRouteId ?? staleRouteId ?? spec.routeId,
+    routeKind: stale ? 'rebase' : 'review',
+    routeLane: stale ? 'split-merge-modules-classes' : details.routeLane ?? spec.routeLane,
+    routeNext: stale ? 'prove-current-branch-output-before-admission' : details.routeNext ?? spec.routeNext,
+    action: stale ? 'rebase' : 'review',
+    status: options.status ?? 'blocked',
+    source: options.source ?? 'classification',
+    subjectKind: classification?.kind,
+    branch: classification?.branch,
+    sourcePath: options.sourcePath,
+    sourcePaths: classification?.sourcePaths,
+    conflictKey: details.conflictKey,
+    reasonCodes: uniqueStrings([classification?.code, details.reasonCode, ...(details.missingRequiredEvidence ?? [])]),
+    requiredEvidence: details.requiredEvidence,
+    missingEvidence: details.missingRequiredEvidence,
+    details
+  });
+}
+
+function projectAdmissionRouteFromConflict(conflict) {
+  const details = conflict?.details ?? {};
+  const classification = {
+    kind: classificationKindFromConflict(conflict, details),
+    code: conflict?.code,
+    branch: details.branch,
+    sourcePaths: uniqueStrings([...(details.sourcePaths ?? []), details.fromSourcePath, details.toSourcePath, details.exportSourcePath, details.importSourcePath, conflict?.sourcePath]),
+    details: { ...details, reasonCode: details.reasonCode ?? conflict?.code }
+  };
+  const route = projectAdmissionRouteFromClassification(classification, {
+    source: 'conflict',
+    sourcePath: conflict?.sourcePath,
+    status: conflict?.severity === 'error' ? 'failed' : 'blocked'
+  });
+  return route?.subjectKind === 'project-admission' && !structuralConflictCode(conflict?.code) && !details.routeId ? undefined : route;
+}
+
+function projectAdmissionRouteFromMissingEvidence(item) {
+  const route = item?.route ?? {};
+  const routeId = item?.routeId ?? route.id;
+  if (!routeId) return undefined;
+  const action = normalizedRouteAction(item?.action);
+  return routeRecord({
+    routeId,
+    routeKind: action,
+    routeLane: item?.routeLane ?? route.lane,
+    routeNext: item?.routeNext ?? route.next,
+    action,
+    status: item?.status ?? 'missing',
+    source: 'missing-evidence',
+    subjectKind: item?.kind,
+    proofLevel: item?.proofLevel,
+    evidenceId: item?.evidenceId,
+    reasonCodes: uniqueStrings([item?.code, ...(item?.relatedSignals ?? [])]),
+    details: item
+  });
+}
+
+function fileAdmissionRoutes(file) {
+  return [
+    ...(file?.admission?.routes ?? []),
+    ...fileAdmissionEvidence(file).map((record) => record.admissionRoute)
+  ].filter(Boolean);
+}
+
+function fileAdmissionEvidence(file) {
+  const records = [file?.summary, file?.metadata].filter(isPlainObject);
+  return records.flatMap((record) => Object.entries(record)
+    .filter(([key, value]) => /Admission(?:Evidence|s)$/.test(key) && Array.isArray(value))
+    .flatMap(([, value]) => value));
+}
+
+function classificationKindFromConflict(conflict, details) {
+  if (details.symbolRenameKind) return 'cross-file-symbol-rename';
+  if (details.symbolMoveKind === 'exported') return 'exported-symbol-move';
+  if (details.symbolMoveKind === 'imported') return 'imported-symbol-move';
+  if (details.movementKind && String(conflict?.code).includes('file-move-rename')) return 'file-move-rename';
+  for (const kind of ['module-split', 'module-merge', 'class-split', 'class-merge']) {
+    if (String(conflict?.code).includes(kind)) return kind;
+  }
+  return structuralConflictCode(conflict?.code) ? 'project-admission' : undefined;
+}
+
+function structuralConflictCode(code) {
+  return /^project-(worker|head)-/.test(String(code ?? ''))
+    || ['project-typescript-refactor-evidence-missing', 'project-source-span-roundtrip-proof-failed'].includes(String(code ?? ''));
+}
+
+function routeRecord(input) {
+  if (!input.routeId) return undefined;
+  return compactRecord({
+    kind: 'frontier.lang.jsTsProjectMergeAdmissionRoute',
+    version: 1,
+    routeId: input.routeId,
+    routeKind: input.routeKind,
+    routeLane: input.routeLane,
+    routeNext: input.routeNext,
+    action: input.action,
+    status: input.status,
+    source: input.source,
+    subjectKind: input.subjectKind,
+    branch: input.branch,
+    sourcePath: input.sourcePath,
+    sourcePaths: input.sourcePaths?.length ? uniqueStrings(input.sourcePaths) : undefined,
+    proofLevel: input.proofLevel,
+    evidenceId: input.evidenceId,
+    conflictKey: input.conflictKey,
+    reasonCodes: input.reasonCodes?.length ? uniqueStrings(input.reasonCodes) : undefined,
+    requiredEvidence: input.requiredEvidence,
+    presentEvidence: input.presentEvidence,
+    missingEvidence: input.missingEvidence,
+    details: input.details,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function uniqueProjectAdmissionRoutes(routes) {
+  const seen = new Set();
+  return routes.filter((route) => {
+    const key = [route.routeId, route.source, route.sourcePath, route.conflictKey, route.evidenceId, route.status].filter(Boolean).join('#');
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function normalizedRouteAction(action) {
+  if (action === 'rerun' || action === 'rerun-gate') return 'rerun';
+  if (action === 'reject-proof' || action === 'reject') return 'reject';
+  if (action === 'block') return 'block';
+  if (action === 'apply') return 'apply';
+  if (action === 'rebase') return 'rebase';
+  return 'review';
+}
+
+function routeSpec(routeId, routeLane, routeNext) { return Object.freeze({ routeId, routeLane, routeNext }); }
+function countField(values, field) { const result = {}; for (const value of values) if (value?.[field]) result[value[field]] = (result[value[field]] ?? 0) + 1; return result; }
+function uniqueStrings(values) { return [...new Set((values ?? []).filter((value) => typeof value === 'string' && value.length > 0))]; }
+function safeToken(value) { return String(value ?? 'project-admission').replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'project-admission'; }
+function isPlainObject(value) { return Boolean(value && typeof value === 'object' && !Array.isArray(value)); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && (!Array.isArray(value) || value.length > 0))); }
+
+export {
+  createProjectAdmissionRoutes,
+  projectAdmissionRouteFromClassification,
+  projectAdmissionRouteFromExactAdmission,
+  projectAdmissionRouteFromMissingEvidence,
+  projectAdmissionRouteSummary
+};