@shapeshift-labs/frontier-lang-compiler 0.2.89 → 0.2.91

package/dist/declarations/semantic-patch-bundle.d.ts

@@ -81,6 +81,8 @@ export interface SemanticPatchBundleAdmission {
   readonly readiness: SemanticMergeReadiness | string;
   readonly reviewRequired: boolean;
   readonly autoMergeClaim: false;
+  readonly autoApplyCandidate?: boolean;
+  readonly transformAdmission?: SemanticPatchBundleTransformAdmission;
   readonly reasonCodes?: readonly string[];
   readonly conflictKeys?: readonly string[];
   readonly admittedAt?: number | string;
@@ -89,6 +91,23 @@ export interface SemanticPatchBundleAdmission {
   readonly metadata?: Record<string, unknown>;
 }
 
+export interface SemanticPatchBundleTransformAdmission {
+  readonly status: 'none' | 'ready' | 'needs-review' | 'blocked' | string;
+  readonly action: 'none' | 'admit' | 'review' | 'block' | string;
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly crossLanguage?: boolean;
+  readonly reasonCodes?: readonly string[];
+  readonly transformIds?: readonly string[];
+  readonly transformKeys?: readonly string[];
+  readonly contentHashes?: readonly string[];
+  readonly projectionIdentityHashes?: readonly string[];
+  readonly sourceLanguages?: readonly string[];
+  readonly targetLanguages?: readonly string[];
+  readonly sourcePaths?: readonly string[];
+  readonly targetPaths?: readonly string[];
+  readonly evidenceIds?: readonly string[];
+}
+
 export interface SemanticPatchBundleRecordIndex {
   readonly baseHashes: readonly string[];
   readonly targetHashes: readonly string[];
@@ -116,6 +135,8 @@ export interface SemanticPatchBundleRecordIndex {
   readonly semanticTransformIdentityHashes: readonly string[];
   readonly semanticTransformContentHashes: readonly string[];
   readonly projectionIdentityHashes: readonly string[];
+  readonly semanticTransformReadinesses: readonly string[];
+  readonly semanticTransformEvidenceIds: readonly string[];
   readonly transformSourceLanguages: readonly string[];
   readonly transformTargetLanguages: readonly string[];
   readonly transformSourcePaths: readonly string[];
@@ -263,6 +284,10 @@ export interface SemanticPatchBundleRecordQuery {
   readonly semanticTransformContentHashes?: readonly string[];
   readonly projectionIdentityHash?: string | readonly string[];
   readonly projectionIdentityHashes?: readonly string[];
+  readonly semanticTransformReadiness?: string | readonly string[];
+  readonly semanticTransformReadinesses?: readonly string[];
+  readonly semanticTransformEvidenceId?: string | readonly string[];
+  readonly semanticTransformEvidenceIds?: readonly string[];
   readonly transformSourceLanguage?: string | readonly string[];
   readonly transformSourceLanguages?: readonly string[];
   readonly transformTargetLanguage?: string | readonly string[];

package/dist/declarations/semantic-transform-identity.d.ts

@@ -44,6 +44,13 @@ export interface CreateSemanticTransformIdentityRecordOptions extends Partial<Se
   readonly operationId?: string;
 }
 
+export interface DeriveSemanticTransformIdentityRecordsOptions extends CreateSemanticTransformIdentityRecordOptions {
+  readonly semanticEditProjection?: unknown;
+  readonly semanticEditProjections?: readonly unknown[] | unknown;
+  readonly projection?: unknown;
+  readonly projections?: readonly unknown[] | unknown;
+}
+
 export type CreateSemanticTransformIdentityRecordInput =
   | Partial<SemanticTransformIdentityRecord>
   | Record<string, unknown>;
@@ -55,3 +62,7 @@ export declare function createSemanticTransformIdentityRecord(
 export declare function semanticTransformIdentityFields(
   record?: SemanticTransformIdentityRecord | Record<string, unknown>
 ): SemanticTransformIdentityRecord;
+export declare function deriveSemanticTransformIdentityRecords(
+  input?: DeriveSemanticTransformIdentityRecordsOptions | Record<string, unknown>,
+  options?: DeriveSemanticTransformIdentityRecordsOptions
+): readonly SemanticTransformIdentityRecord[];

package/dist/index.js

@@ -68,7 +68,7 @@ export { queryNativeParserFeatureMatrix } from './internal/index-impl/queryNativ
 export { queryProjectionReadinessMatrix } from './internal/index-impl/queryProjectionReadinessMatrix.js';
 export { createSemanticPatchBundleRecord, querySemanticPatchBundleRecords, SemanticPatchBundleAdmissionStatuses } from './internal/index-impl/semanticPatchBundleRecords.js';
 export { compareSemanticPatchBundleRecords, querySemanticPatchBundleOverlaps, SemanticPatchBundleOverlapKinds, SemanticPatchBundleOverlapStatuses } from './internal/index-impl/semanticPatchBundleOverlaps.js';
-export { createSemanticTransformIdentityRecord, semanticTransformIdentityFields } from './internal/index-impl/semanticTransformIdentityRecords.js';
+export { createSemanticTransformIdentityRecord, deriveSemanticTransformIdentityRecords, semanticTransformIdentityFields } from './internal/index-impl/semanticTransformIdentityRecords.js';
 export { createSemanticMergeCandidateAdmissionRecord, decorateSemanticMergeCandidateForAdmission, querySemanticMergeCandidateAdmissionOverlaps, SemanticMergeCandidateProjectionRisks, semanticMergeCandidateReadinessSortKey, sortSemanticMergeCandidateAdmissionRecords } from './internal/index-impl/semanticMergeCandidateRecords.js';
 export { querySemanticMergeConflictClasses, SemanticMergeConflictClasses, semanticMergeConflictRiskScore, sortSemanticMergeCandidatesByConflictRisk, summarizeSemanticMergeConflicts } from './internal/index-impl/semanticMergeConflicts.js';
 export { createSemanticEditScript, SemanticEditScriptAdmissionStatuses } from './internal/index-impl/semanticEditScripts.js';

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

@@ -0,0 +1,97 @@
+import { normalizeSemanticMergeReadiness, uniqueStrings } from '../../native-import-utils.js';
+
+export function createSemanticPatchBundleAdmission(input = {}, context = {}) {
+  const transformAdmission = semanticTransformAdmission(context);
+  const fallbackReadiness = transformAdmission.readiness === 'ready' ? 'ready' : context.readiness;
+  const readiness = normalizeSemanticMergeReadiness(input.readiness ?? fallbackReadiness) ?? input.readiness ?? fallbackReadiness;
+  const status = input.status ?? admissionStatusForReadiness(readiness, transformAdmission);
+  const autoApplyCandidate = input.autoApplyCandidate ?? (status === 'admitted' && transformAdmission.action === 'admit');
+  return compactRecord({
+    status,
+    readiness,
+    reviewRequired: input.reviewRequired ?? status !== 'admitted',
+    autoMergeClaim: false,
+    autoApplyCandidate,
+    transformAdmission,
+    reasonCodes: uniqueStrings([
+      ...strings(input.reasonCodes),
+      ...strings(context.source?.reasons),
+      ...strings(context.mergeCandidate?.reasons),
+      ...transformAdmission.reasonCodes
+    ]),
+    conflictKeys: uniqueStrings([...strings(input.conflictKeys), ...context.conflictKeys]),
+    admittedAt: input.admittedAt,
+    reviewerId: input.reviewerId,
+    evidenceIds: uniqueStrings([...strings(input.evidenceIds), ...strings(transformAdmission.evidenceIds)]),
+    metadata: input.metadata
+  });
+}
+
+function semanticTransformAdmission(context) {
+  const records = array(context.semanticTransformIdentities);
+  const index = context.semanticTransformIndex ?? {};
+  if (!records.length && !strings(index.semanticTransformIds).length) {
+    return { status: 'none', action: 'none', readiness: 'needs-review', reasonCodes: [] };
+  }
+  const readinesses = uniqueStrings([...strings(index.semanticTransformReadinesses), ...records.map((record) => record.readiness)]);
+  const normalizedReadinesses = uniqueStrings(readinesses.map(transformReadiness).filter(Boolean));
+  const blocked = normalizedReadinesses.includes('blocked');
+  const complete = strings(index.semanticTransformContentHashes).length > 0 &&
+    strings(index.projectionIdentityHashes).length > 0 &&
+    strings(index.transformSourceLanguages).length > 0 &&
+    strings(index.transformTargetLanguages).length > 0 &&
+    strings(index.transformSourcePaths).length > 0 &&
+    strings(index.transformTargetPaths).length > 0;
+  const ready = !blocked && complete && (normalizedReadinesses.length === 0 || normalizedReadinesses.every((entry) => entry === 'ready'));
+  const status = blocked ? 'blocked' : ready ? 'ready' : 'needs-review';
+  return compactRecord({
+    status,
+    action: blocked ? 'block' : ready ? 'admit' : 'review',
+    readiness: blocked ? 'blocked' : ready ? 'ready' : 'needs-review',
+    crossLanguage: hasCrossLanguageTransform(index),
+    reasonCodes: transformReasonCodes({ blocked, complete, ready, readinesses, index }),
+    transformIds: strings(index.semanticTransformIds),
+    transformKeys: strings(index.semanticTransformKeys),
+    contentHashes: strings(index.semanticTransformContentHashes),
+    projectionIdentityHashes: strings(index.projectionIdentityHashes),
+    sourceLanguages: strings(index.transformSourceLanguages),
+    targetLanguages: strings(index.transformTargetLanguages),
+    sourcePaths: strings(index.transformSourcePaths),
+    targetPaths: strings(index.transformTargetPaths),
+    evidenceIds: strings(index.semanticTransformEvidenceIds)
+  });
+}
+
+function transformReasonCodes(input) {
+  return uniqueStrings([
+    input.blocked ? 'transform-readiness-blocked' : undefined,
+    !input.complete ? 'transform-evidence-incomplete' : undefined,
+    input.ready ? 'transform-auto-apply-candidate' : undefined,
+    ...input.readinesses.map((readiness) => `transform-readiness:${readiness}`)
+  ]);
+}
+
+function transformReadiness(value) {
+  const normalized = normalizeSemanticMergeReadiness(value);
+  if (normalized) return normalized === 'ready-with-losses' ? 'needs-review' : normalized;
+  const status = String(value ?? '').toLowerCase();
+  if (['auto-merge-candidate', 'portable', 'projected', 'applied'].includes(status)) return 'ready';
+  if (['conflict', 'blocked', 'stale', 'rejected'].includes(status)) return 'blocked';
+  if (['needs-port', 'review', 'needs-review', 'candidate'].includes(status)) return 'needs-review';
+  return undefined;
+}
+
+function admissionStatusForReadiness(readiness, transformAdmission) {
+  if (readiness === 'blocked') return 'blocked';
+  if (transformAdmission.action === 'admit' && readiness === 'ready') return 'admitted';
+  return readiness === 'needs-review' ? 'needs-review' : 'proposed';
+}
+
+function hasCrossLanguageTransform(index) {
+  const source = new Set(strings(index.transformSourceLanguages));
+  return strings(index.transformTargetLanguages).some((target) => !source.has(target));
+}
+
+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); }
+function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }

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

@@ -1,4 +1,5 @@
 import{idFragment,normalizeSemanticMergeReadiness,uniqueStrings}from'../../native-import-utils.js';
+import{createSemanticPatchBundleAdmission}from'./semanticPatchBundleAdmission.js';
 import{normalizeSemanticTransformIdentityRecords,semanticTransformInputs,semanticTransformRecordIndex,semanticTransformSummary}from'./semanticTransformIdentityRecords.js';
 
 export const SemanticPatchBundleAdmissionStatuses=Object.freeze(['proposed','queued','admitted','needs-review','blocked','rejected']);
@@ -42,7 +43,7 @@ export function createSemanticPatchBundleRecord(input={},options={}){
     ...changedRegions.flatMap((region)=>[region.conflictKey,...array(region.admission?.conflictKeys)]),
     ...(source.metadata?.semanticMergeConflictSummary?.conflictKeys??[])
   ]);
-  const admission=normalizeAdmission(options.admission??source.admission,{readiness,conflictKeys,source,mergeCandidate});
+  const admission=createSemanticPatchBundleAdmission(options.admission??source.admission,{readiness,conflictKeys,source,mergeCandidate,semanticTransformIndex,semanticTransformIdentities});
   const id=options.id??(source.kind==='frontier.lang.semanticPatchBundleRecord'?source.id:undefined)
     ??`semantic_patch_bundle_${idFragment(firstString(source.id,patchId,mergeCandidateId,source.sourcePath,source.language,'record'))}`;
   const language=options.language??source.language??mergeCandidate?.language??sources.find((item)=>item.language)?.language;
@@ -184,23 +185,6 @@ function normalizeSourceMapLinks(links){
   return result;
 }
 
-function normalizeAdmission(input={},context){
-  const readiness=normalizeSemanticMergeReadiness(input.readiness??context.readiness)??input.readiness??context.readiness;
-  const status=input.status??admissionStatusForReadiness(readiness);
-  return compactRecord({
-    status,
-    readiness,
-    reviewRequired:input.reviewRequired??status!=='admitted',
-    autoMergeClaim:false,
-    reasonCodes:uniqueStrings([...strings(input.reasonCodes),...strings(context.source.reasons),...strings(context.mergeCandidate?.reasons)]),
-    conflictKeys:uniqueStrings([...strings(input.conflictKeys),...context.conflictKeys]),
-    admittedAt:input.admittedAt,
-    reviewerId:input.reviewerId,
-    evidenceIds:uniqueStrings(input.evidenceIds),
-    metadata:input.metadata
-  });
-}
-
 function recordIndex(parts){
   const semanticEditIndex=parts.semanticEditIndex??semanticEditRecordIndex([],[]);
   const semanticTransformIndex=parts.semanticTransformIndex??semanticTransformRecordIndex([],parts);
@@ -231,6 +215,8 @@ function recordIndex(parts){
     semanticTransformIdentityHashes:semanticTransformIndex.semanticTransformIdentityHashes,
     semanticTransformContentHashes:semanticTransformIndex.semanticTransformContentHashes,
     projectionIdentityHashes:semanticTransformIndex.projectionIdentityHashes,
+    semanticTransformReadinesses:semanticTransformIndex.semanticTransformReadinesses,
+    semanticTransformEvidenceIds:semanticTransformIndex.semanticTransformEvidenceIds,
     transformSourceLanguages:semanticTransformIndex.transformSourceLanguages,
     transformTargetLanguages:semanticTransformIndex.transformTargetLanguages,
     transformSourcePaths:semanticTransformIndex.transformSourcePaths,
@@ -273,6 +259,8 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.semanticTransformIdentityHash,query.semanticTransformIdentityHashes),index.semanticTransformIdentityHashes)
     &&matchAny(queryValues(query.semanticTransformContentHash,query.semanticTransformContentHashes),index.semanticTransformContentHashes)
     &&matchAny(queryValues(query.projectionIdentityHash,query.projectionIdentityHashes),index.projectionIdentityHashes)
+    &&matchAny(queryValues(query.semanticTransformReadiness,query.semanticTransformReadinesses),index.semanticTransformReadinesses)
+    &&matchAny(queryValues(query.semanticTransformEvidenceId,query.semanticTransformEvidenceIds),index.semanticTransformEvidenceIds)
     &&matchAny(queryValues(query.transformSourceLanguage,query.transformSourceLanguages),index.transformSourceLanguages)
     &&matchAny(queryValues(query.transformTargetLanguage,query.transformTargetLanguages),index.transformTargetLanguages)
     &&matchAny(queryValues(query.transformSourcePath,query.transformSourcePaths),index.transformSourcePaths)
@@ -281,7 +269,6 @@ function matchesRecord(record,query){
     &&matchAny(queryValues(query.admissionStatus,query.admissionStatuses),index.admissionStatuses);
 }
 
-function admissionStatusForReadiness(readiness){return readiness==='blocked'?'blocked':readiness==='needs-review'?'needs-review':'proposed';}
 function semanticEditRecordIndex(scripts,projections,source={}){
   const operations=scripts.flatMap((script)=>array(script.operations));
   const edits=projections.flatMap((projection)=>array(projection.edits));

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

@@ -72,17 +72,30 @@ export function semanticTransformIdentityFields(record = {}) {
 }
 
 export function normalizeSemanticTransformIdentityRecords(records, context = {}) {
-  return array(records).filter(Boolean).map((record) => createSemanticTransformIdentityRecord(record, context));
+  return uniqueRecords(array(records).filter(Boolean).map((record) => createSemanticTransformIdentityRecord(record, context)));
 }
 
 export function semanticTransformInputs(source = {}, options = {}) {
+  const projections = [
+    ...array(options.semanticEditProjections ?? options.semanticEditProjection),
+    ...array(source.semanticEditProjections ?? source.semanticEditProjection)
+  ];
   return [
     ...array(options.semanticTransformIdentities ?? options.semanticTransformIdentity),
     ...array(source.semanticTransformIdentities ?? source.semanticTransformIdentity ?? source.semanticTransforms),
-    ...array(source.index?.semanticTransformIdentities)
+    ...array(source.index?.semanticTransformIdentities),
+    ...deriveSemanticTransformIdentityRecords({ semanticEditProjections: projections }, { ...source, ...options })
   ];
 }
 
+export function deriveSemanticTransformIdentityRecords(input = {}, options = {}) {
+  const projections = semanticEditProjectionInputs(input);
+  return uniqueRecords(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));
+  }));
+}
+
 export function semanticTransformRecordIndex(records, source = {}) {
   const index = source.index ?? {};
   return {
@@ -91,6 +104,8 @@ 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)]),
+    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)]),
@@ -106,6 +121,8 @@ export function semanticTransformSummary(index) {
     identityHashes: index.semanticTransformIdentityHashes,
     contentHashes: index.semanticTransformContentHashes,
     projectionIdentityHashes: index.projectionIdentityHashes,
+    readinesses: index.semanticTransformReadinesses,
+    evidenceIds: index.semanticTransformEvidenceIds,
     sourceLanguages: index.transformSourceLanguages,
     targetLanguages: index.transformTargetLanguages,
     targetPaths: index.transformTargetPaths
@@ -120,6 +137,49 @@ function semanticTransformKey(record) {
   return ['semantic-transform', route, scope].filter(Boolean).join(':');
 }
 
+function semanticEditProjectionInputs(input) {
+  if (input.kind === 'frontier.lang.semanticEditProjection') return [input];
+  return [
+    ...array(input.semanticEditProjections ?? input.semanticEditProjection),
+    ...array(input.projections ?? input.projection)
+  ].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 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 transformId = [projection.id, edit.operationId, projectionIndex, editIndex].filter((entry) => entry !== undefined && entry !== null).join(':');
+  return createSemanticTransformIdentityRecord(edit, {
+    id: `semantic_transform_${idFragment(transformId)}`,
+    sourceLanguage,
+    targetLanguage,
+    sourcePath,
+    targetPath,
+    baseHash: firstString(edit.baseHash, projection.baseHash, input.baseHash, options.baseHash),
+    targetHash: firstString(edit.targetHash, projection.projectedHash, projection.targetHash, input.targetHash, options.targetHash),
+    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({
+      sourceProjectionId: projection.id,
+      sourceProjectionEditOperationId: edit.operationId
+    })
+  });
+}
+
+function uniqueRecords(records) {
+  const seen = new Set();
+  const result = [];
+  for (const record of records) {
+    const key = firstString(record.id, record.transformContentHash, record.projectionIdentityHash, record.transformIdentityHash);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    result.push(record);
+  }
+  return result;
+}
+
 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); }
 function firstString(...values) { return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shapeshift-labs/frontier-lang-compiler",
-  "version": "0.2.89",
+  "version": "0.2.91",
   "description": "Compiler facade for Frontier Lang source documents and language projection adapters.",
   "type": "module",
   "main": "./dist/index.js",