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

package/dist/js-ts-safe-project-merge-quality-gates.js

@@ -0,0 +1,140 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+
+const passStatuses = new Set(['passed', 'pass', 'ok', 'clean', 'accepted-clean', 'success']);
+const qualityGateRerunRoute = Object.freeze({
+  id: 'rerun-project-quality-gate',
+  lane: 'quality-gates',
+  next: 'rerun-failing-quality-gate'
+});
+
+function createJsTsProjectMergeQualityGate(input = {}, id = 'js_ts_project_safe_merge') {
+  const gates = [
+    ...normalizeGates(input.qualityGates),
+    ...normalizeGates(input.lintGates, 'lint'),
+    ...normalizeGates(input.formatGates, 'format'),
+    ...normalizeGates(input.testGates, 'test'),
+    ...normalizeGates(input.buildGates, 'build')
+  ];
+  if (!gates.length) return undefined;
+  const conflicts = gates.filter((gate) => !passStatuses.has(gate.status)).map(gateConflict);
+  const status = conflicts.length ? 'blocked' : 'passed';
+  return {
+    kind: 'frontier.lang.jsTsProjectMergeQualityGate',
+    version: 1,
+    id: `${id}_quality_gate`,
+    status,
+    gates,
+    conflicts,
+    evidence: qualityGateEvidence(id, gates),
+    decision: qualityGateDecision(status, conflicts),
+    summary: {
+      gates: gates.length,
+      passed: gates.filter((gate) => passStatuses.has(gate.status)).length,
+      failed: conflicts.length,
+      lint: countCategory(gates, 'lint'),
+      format: countCategory(gates, 'format'),
+      test: countCategory(gates, 'test'),
+      build: countCategory(gates, 'build')
+    }
+  };
+}
+
+function qualityGateEvidence(id, gates) {
+  return gates.map((gate) => ({
+    id: gate.evidenceId ?? `${id}_${gate.category}_${gate.id}_evidence`,
+    kind: `js-ts-project-${gate.category}-gate`,
+    status: passStatuses.has(gate.status) ? 'passed' : 'failed',
+    summary: passStatuses.has(gate.status)
+      ? `Project ${gate.category} gate ${JSON.stringify(gate.id)} passed.`
+      : `Project ${gate.category} gate ${JSON.stringify(gate.id)} did not pass.`,
+    metadata: compactRecord({
+      gateId: gate.id,
+      category: gate.category,
+      command: gate.command,
+      artifactPath: gate.artifactPath,
+      admissionAction: passStatuses.has(gate.status) ? 'apply' : 'block',
+      nextMissingEvidence: passStatuses.has(gate.status) ? undefined : gateMissingEvidence(gate),
+      autoMergeClaim: false,
+      semanticEquivalenceClaim: false
+    })
+  }));
+}
+
+function normalizeGates(value, category) {
+  const entries = Array.isArray(value) ? value : value ? [value] : [];
+  return entries.filter((entry) => entry && typeof entry === 'object').map((entry, index) => compactRecord({
+    id: String(entry.id ?? entry.gateId ?? `${category ?? entry.category ?? 'quality'}_${index + 1}`),
+    category: String(entry.category ?? category ?? 'quality'),
+    status: String(entry.status ?? entry.result ?? 'failed').toLowerCase(),
+    command: entry.command,
+    artifactPath: entry.artifactPath ?? entry.path,
+    evidenceId: entry.evidenceId,
+    summary: entry.summary,
+    reasonCode: entry.reasonCode
+  }));
+}
+
+function gateConflict(gate) {
+  const code = gate.reasonCode ?? `project-${gate.category}-gate-failed`;
+  const nextMissingEvidence = gateMissingEvidence(gate, code);
+  return {
+    code,
+    gateId: 'project-quality-gate',
+    message: `Project ${gate.category} gate ${JSON.stringify(gate.id)} did not pass.`,
+    sourcePath: gate.artifactPath,
+    details: compactRecord({
+      reasonCode: code,
+      conflictKey: `project-quality-gate#${gate.category}#${gate.id}`,
+      gateId: gate.id,
+      category: gate.category,
+      status: gate.status,
+      command: gate.command,
+      artifactPath: gate.artifactPath,
+      evidenceId: gate.evidenceId,
+      admissionAction: 'block',
+      requiredEvidence: `${gate.category} gate ${JSON.stringify(gate.id)} passed`,
+      nextMissingEvidence
+    })
+  };
+}
+
+function qualityGateDecision(status, conflicts) {
+  const reasonCodes = conflicts.map((conflict) => conflict.code).filter(Boolean);
+  return compactRecord({
+    status,
+    action: status === 'passed' ? 'apply' : 'block',
+    reviewRequired: status !== 'passed',
+    autoApplyCandidate: status === 'passed',
+    reasonCodes,
+    nextMissingEvidence: conflicts[0]?.details?.nextMissingEvidence,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function gateMissingEvidence(gate, reasonCode = gate.reasonCode ?? `project-${gate.category}-gate-failed`) {
+  return compactRecord({
+    code: reasonCode,
+    kind: 'quality-gate',
+    scope: 'quality-gates',
+    status: 'missing-or-failed',
+    action: 'rerun-gate',
+    route: qualityGateRerunRoute,
+    routeId: qualityGateRerunRoute.id,
+    routeLane: qualityGateRerunRoute.lane,
+    routeNext: qualityGateRerunRoute.next,
+    gateId: gate.id,
+    category: gate.category,
+    command: gate.command,
+    artifactPath: gate.artifactPath,
+    summary: `Provide a passing ${gate.category} gate for ${JSON.stringify(gate.id)} before applying the project merge.`,
+    autoMergeClaim: false,
+    semanticEquivalenceClaim: false
+  });
+}
+
+function countCategory(gates, category) {
+  return gates.filter((gate) => gate.category === category).length;
+}
+
+export { createJsTsProjectMergeQualityGate };

package/dist/js-ts-safe-project-merge-routing-calibration.js

@@ -0,0 +1,125 @@
+function compactProjectMergeRoutingCalibration(missingEvidence = [], proofEvidence = undefined) {
+  const missingRoutes = missingEvidence.map(missingRouteRecord).filter(Boolean);
+  const proofSummary = proofEvidence?.summary ?? {};
+  const focusedRouteCounts = proofSummary.unsupportedSurfaceProofGapRouteCounts ?? {};
+  const focusedLaneCounts = proofSummary.unsupportedSurfaceProofGapRouteLaneCounts ?? {};
+  const byRoute = mergeCounts(countField(missingRoutes, 'routeId'), focusedRouteCounts);
+  const byLane = mergeCounts(countField(missingRoutes, 'routeLane'), focusedLaneCounts);
+  const routeWorklist = compactRouteWorklist(missingRoutes, proofSummary, byRoute);
+  const next = missingRoutes[0];
+  return compactRecord({
+    kind: 'frontier.lang.jsTsProjectMergeRoutingCalibration',
+    version: 1,
+    schema: 'frontier.lang.jsTsProjectMergeRoutingCalibration.v1',
+    routes: Object.keys(byRoute).length,
+    missingRoutes: missingRoutes.length,
+    focusedProofGapRoutes: sumCounts(focusedRouteCounts),
+    byRoute,
+    byLane,
+    byAction: countField(missingEvidence, 'action'),
+    byProofLevel: countField(missingEvidence, 'proofLevel'),
+    routeWorklist,
+    routeWorklistCount: routeWorklist.length,
+    nextRouteWork: routeWorklist[0],
+    nextRouteId: next?.routeId,
+    nextRouteLane: next?.routeLane,
+    nextRouteNext: next?.routeNext,
+    nextAction: next?.action,
+    nextProofLevel: next?.proofLevel,
+    nextFocusedProofGapRouteId: proofSummary.nextUnsupportedSurfaceProofGapRouteId,
+    nextFocusedProofGapRouteLane: proofSummary.nextUnsupportedSurfaceProofGapRouteLane,
+    nextFocusedProofGapCode: proofSummary.nextUnsupportedSurfaceProofGapCode
+  });
+}
+
+function compactRouteWorklist(missingRoutes, proofSummary = {}, byRoute = {}) {
+  const byId = new Map();
+  for (const route of missingRoutes) {
+    const existing = byId.get(route.routeId) ?? {
+      routeId: route.routeId,
+      routeLane: route.routeLane,
+      routeNext: route.routeNext,
+      action: route.action,
+      proofLevel: route.proofLevel,
+      codes: [],
+      missingEvidenceCount: 0,
+      focusedProofGapCount: 0
+    };
+    existing.codes = uniqueStrings([...existing.codes, route.code]);
+    existing.missingEvidenceCount += 1;
+    byId.set(route.routeId, existing);
+  }
+  for (const routeId of Object.keys(proofSummary.unsupportedSurfaceProofGapRouteCounts ?? {}).sort()) {
+    const existing = byId.get(routeId) ?? {
+      routeId,
+      routeLane: focusedRouteLane(routeId, proofSummary),
+      routeNext: undefined,
+      action: 'review',
+      proofLevel: 'unsupported-js-ts-surface-review',
+      codes: [],
+      missingEvidenceCount: 0,
+      focusedProofGapCount: 0
+    };
+    existing.focusedProofGapCount += Number(proofSummary.unsupportedSurfaceProofGapRouteCounts?.[routeId] ?? 0);
+    existing.codes = uniqueStrings([...existing.codes, focusedRouteCode(routeId, proofSummary)]);
+    byId.set(routeId, existing);
+  }
+  return [...byId.values()]
+    .map((route) => compactRecord({
+      ...route,
+      count: Number(byRoute[route.routeId] ?? 0) || route.missingEvidenceCount + route.focusedProofGapCount,
+      codes: route.codes.length ? route.codes : undefined
+    }))
+    .sort((left, right) => routeRank(left) - routeRank(right) || left.routeId.localeCompare(right.routeId));
+}
+
+function routeRank(route) {
+  const actionRank = route.action === 'rerun-gate' ? 0 : route.action === 'block' ? 1 : 2;
+  return actionRank * 100000 - Number(route.count ?? 0) * 1000;
+}
+
+function focusedRouteLane(routeId, proofSummary) {
+  if (routeId === proofSummary.nextUnsupportedSurfaceProofGapRouteId) return proofSummary.nextUnsupportedSurfaceProofGapRouteLane;
+  const routeIds = proofSummary.unsupportedSurfaceProofGapRouteIds ?? [];
+  const lanes = proofSummary.unsupportedSurfaceProofGapRouteLanes ?? [];
+  const index = routeIds.indexOf(routeId);
+  return index >= 0 ? lanes[index] : undefined;
+}
+
+function focusedRouteCode(routeId, proofSummary) {
+  return routeId === proofSummary.nextUnsupportedSurfaceProofGapRouteId
+    ? proofSummary.nextUnsupportedSurfaceProofGapCode
+    : undefined;
+}
+
+function missingRouteRecord(item) {
+  const route = item?.route ?? {};
+  const routeId = item?.routeId ?? route.id;
+  if (!routeId) return undefined;
+  return compactRecord({
+    routeId,
+    routeLane: item?.routeLane ?? route.lane,
+    routeNext: item?.routeNext ?? route.next,
+    action: item?.action,
+    proofLevel: item?.proofLevel,
+    code: item?.code
+  });
+}
+
+function countField(items, field) {
+  const counts = {};
+  for (const item of items) if (item?.[field]) counts[item[field]] = (counts[item[field]] ?? 0) + 1;
+  return counts;
+}
+
+function mergeCounts(...countsList) {
+  const merged = {};
+  for (const counts of countsList) for (const [key, value] of Object.entries(counts ?? {})) merged[key] = (merged[key] ?? 0) + Number(value ?? 0);
+  return merged;
+}
+
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+function sumCounts(counts) { return Object.values(counts ?? {}).reduce((total, value) => total + Number(value ?? 0), 0); }
+function compactRecord(record) { return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined)); }
+
+export { compactProjectMergeRoutingCalibration };

package/dist/js-ts-safe-project-merge-runtime-region-conflicts.js

@@ -0,0 +1,156 @@
+import { compactRecord } from './js-ts-safe-merge-context.js';
+import { runtimeOrderEvidenceBinding } from './internal/index-impl/runtimeOrderEvidenceBinding.js';
+import { runtimeOrderReasonCodes } from './internal/index-impl/semanticEditRuntimeOrderReasons.js';
+
+function projectRuntimeRegionDeltaConflicts(projectGraphDelta, options = {}) {
+  const baseGraph = projectGraphDelta?.stages?.base?.projectSymbolGraph;
+  const workerGraph = projectGraphDelta?.stages?.worker?.projectSymbolGraph;
+  const headGraph = projectGraphDelta?.stages?.head?.projectSymbolGraph;
+  const outputGraph = projectGraphDelta?.stages?.output?.projectSymbolGraph;
+  if (!baseGraph || !workerGraph || !headGraph) return [];
+  const base = runtimeRecordsByIdentityKey(baseGraph.runtimeRegionRecords);
+  const worker = runtimeRecordsByIdentityKey(workerGraph.runtimeRegionRecords);
+  const head = runtimeRecordsByIdentityKey(headGraph.runtimeRegionRecords);
+  const output = runtimeRecordsByIdentityKey(outputGraph?.runtimeRegionRecords);
+  return uniqueStrings([...base.keys(), ...worker.keys(), ...head.keys()]).flatMap((identityKey) => {
+    const baseRecord = base.get(identityKey);
+    const workerRecord = worker.get(identityKey);
+    const headRecord = head.get(identityKey);
+    const fingerprints = [runtimeFingerprint(baseRecord), runtimeFingerprint(workerRecord), runtimeFingerprint(headRecord)];
+    if (fingerprints[0] === fingerprints[1] || fingerprints[0] === fingerprints[2] || fingerprints[1] === fingerprints[2]) return [];
+    const explicitEvidence = projectRuntimeOrderEvidenceBinding(identityKey, baseRecord, workerRecord, headRecord, output.get(identityKey), options);
+    if (explicitEvidence.passed) return [];
+    return [projectRuntimeRegionDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, output.get(identityKey), explicitEvidence)];
+  });
+}
+
+function projectRuntimeRegionDeltaConflict(identityKey, baseRecord, workerRecord, headRecord, outputRecord, explicitEvidence) {
+  const sourcePath = workerRecord?.sourcePath ?? headRecord?.sourcePath ?? baseRecord?.sourcePath;
+  return {
+    code: 'project-public-runtime-region-delta-conflict',
+    gateId: 'project-graph-delta',
+    message: `Worker and head both changed public runtime region ${JSON.stringify(identityKey)} in incompatible ways.`,
+    sourcePath,
+    details: compactRecord({
+      reasonCode: 'project-public-runtime-region-delta-conflict',
+      conflictKey: `project-graph-delta#runtime-region#${identityKey}`,
+      identityKey,
+      sourcePath,
+      reasonCodes: runtimeConflictReasonCodes(baseRecord, workerRecord, headRecord, outputRecord, explicitEvidence),
+      explicitRuntimeOrderEvidence: explicitEvidenceDetails(explicitEvidence),
+      base: runtimeDetails(baseRecord),
+      worker: runtimeDetails(workerRecord),
+      head: runtimeDetails(headRecord),
+      output: runtimeDetails(outputRecord)
+    })
+  };
+}
+
+function projectRuntimeOrderEvidenceBinding(identityKey, baseRecord, workerRecord, headRecord, outputRecord, options) {
+  return runtimeOrderEvidenceBinding({
+    scriptInput: {
+      runtimeOrderEvidence: runtimeOrderEvidenceCandidates(options),
+      evidence: options.evidence
+    },
+    region: outputRecord ?? workerRecord ?? headRecord ?? baseRecord,
+    baseSymbol: baseRecord,
+    workerSymbol: workerRecord,
+    headSymbol: headRecord,
+    anchorKey: workerRecord?.key ?? headRecord?.key ?? baseRecord?.key ?? identityKey,
+    context: {
+      workerChangeSet: {
+        sourcePath: workerRecord?.sourcePath ?? baseRecord?.sourcePath,
+        beforeHash: baseRecord?.sourceHash,
+        afterHash: workerRecord?.sourceHash
+      },
+      headChangeSet: {
+        sourcePath: headRecord?.sourcePath ?? baseRecord?.sourcePath,
+        afterHash: headRecord?.sourceHash
+      }
+    }
+  });
+}
+
+function runtimeOrderEvidenceCandidates(options) {
+  return [
+    ...array(options.runtimeOrderEvidence),
+    ...array(options.projectRuntimeOrderEvidence),
+    ...array(options.metadata?.runtimeOrderEvidence)
+  ];
+}
+
+function runtimeRecordsByIdentityKey(records = []) {
+  const result = new Map();
+  for (const record of records) {
+    if (!record?.publicContract) continue;
+    const key = runtimeIdentityKey(record);
+    if (key && !result.has(key)) result.set(key, record);
+  }
+  return result;
+}
+
+function runtimeIdentityKey(record) {
+  return stableKey(['runtime-region', record?.sourcePath, record?.symbolName, record?.regionKind, record?.runtimeKind, record?.ordinal]);
+}
+
+function runtimeFingerprint(record) { return record ? stableKey([record.signatureHash, record.regionKind, record.runtimeKind]) : undefined; }
+function runtimeDetails(record) {
+  if (!record) return undefined;
+  return compactRecord({
+    sourcePath: record.sourcePath,
+    symbolName: record.symbolName,
+    symbolKind: record.symbolKind,
+    regionKind: record.regionKind,
+    runtimeKind: record.runtimeKind,
+    runtimeKinds: record.runtimeKinds,
+    line: record.line,
+    ordinal: record.ordinal,
+    spanKind: record.spanKind,
+    runtimeOrderEvidence: record.runtimeOrderEvidence,
+    reasonCodes: runtimeRecordReasonCodes(record),
+    signatureHash: record.signatureHash,
+    sourceHash: record.sourceHash
+  });
+}
+
+function runtimeConflictReasonCodes(...records) {
+  const explicitEvidence = records.find((record) => record?.reasonCodes);
+  const runtimeRecords = records.filter((record) => !record?.reasonCodes);
+  return uniqueStrings([
+    'project-public-runtime-region-delta-conflict',
+    ...(explicitEvidence?.reasonCodes ?? []),
+    ...runtimeRecords.flatMap(runtimeRecordReasonCodes)
+  ]);
+}
+
+function explicitEvidenceDetails(evidence) {
+  if (!evidence?.reasonCodes?.length) return undefined;
+  return {
+    status: 'failed',
+    reasonCodes: evidence.reasonCodes,
+    evidenceIds: evidence.evidenceIds
+  };
+}
+
+function runtimeRecordReasonCodes(record) {
+  if (!record) return [];
+  return runtimeOrderReasonCodes({
+    region: {
+      ...record,
+      metadata: {
+        factKinds: record.runtimeKinds ?? (record.runtimeKind ? [record.runtimeKind] : undefined),
+        runtimeOrderEvidence: record.runtimeOrderEvidence,
+        subjectName: record.symbolName
+      }
+    }
+  });
+}
+
+function stableKey(parts) {
+  const values = parts.map((part) => part === undefined || part === null ? '' : String(part));
+  return values.some(Boolean) ? values.join('#') : undefined;
+}
+function uniqueStrings(values) { return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))]; }
+function array(value) { return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value]; }
+
+export { projectRuntimeRegionDeltaConflicts };