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

package/README.md

@@ -162,6 +162,20 @@ const overlaps = querySemanticMergeCandidateAdmissionOverlaps(queue);
 
 These candidate records are compact merge-admission evidence. They preserve changed semantic regions, source/base/target hashes, conflict keys, evidence IDs, projection risk, readiness, and overlap pairs so swarm coordinators can sort likely-ready candidates first and detect conflicting regions before patch review.
 
+The JS/TS semantic merge smoke corpus lives at
+`test/fixtures/js-ts-semantic-merge/corpus.json` and is exercised by
+`test/smoke/js-ts-fixture-corpus.mjs` plus
+`test/smoke/js-ts-semantic-merge-oracles.mjs`. The fixtures are deliberately
+small and dependency-free. They cover accepted projection/replay cases, exact
+source preservation, generated/source-map boundaries, safe import/declaration
+merges, safe unordered member merges, composed top-level/member safe merges,
+and rejected unsafe cases such as stale
+ledger spans, import specifier reordering, computed keys, duplicate exported
+names, duplicate object members, decorators, overload anchors, and same-anchor
+edit conflicts. Fixture failures include the fixture id and the actual
+reason-code or gate values so distributed swarm evidence can point at a stable
+case instead of an agent transcript.
+
 High-risk native features also have explicit evidence policies. These policies are advisory in this package: they tell a swarm or admission queue what evidence is missing without silently changing the existing readiness classification.
 
 ```js

package/dist/declarations/bidirectional-target-change-source-edit.d.ts

@@ -0,0 +1,30 @@
+import type { SemanticMergeReadiness } from '@shapeshift-labs/frontier-lang-kernel';
+import type { BidirectionalTargetPortabilityAction } from './bidirectional-target-change-evidence.js';
+
+export interface BidirectionalTargetChangeSourceEditProjectionHint {
+  readonly schema: 'frontier.lang.bidirectionalTargetChangeSourceEditProjectionHint.v1';
+  readonly version: 1;
+  readonly id: string;
+  readonly scriptId: string;
+  readonly hash: string;
+  readonly status: 'portable' | string;
+  readonly action: BidirectionalTargetPortabilityAction;
+  readonly readiness: SemanticMergeReadiness | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly targetPath?: string;
+  readonly targetHash?: string;
+  readonly targetChangeSetId: string;
+  readonly targetPatchId?: string;
+  readonly targetMergeCandidateId?: string;
+  readonly sourceAnchorMatchIds: readonly string[];
+  readonly sourceAnchorKeys: readonly string[];
+  readonly sourceMapLinkIds: readonly string[];
+  readonly sourceMapIds: readonly string[];
+  readonly sourceMapMappingIds: readonly string[];
+  readonly operationIds: readonly string[];
+  readonly reviewRequired: true;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+  readonly reasonCodes: readonly string[];
+}

package/dist/declarations/bidirectional-target-change.d.ts

@@ -8,7 +8,9 @@ import type { ImportNativeSourceOptions, NativeSourceImportResult } from './impo
 import type { NativeSourceChangeSet } from './native-diff.js';
 import type { SemanticHistoryRecord } from './semantic-history.js';
 import type { SemanticLineageEvent } from './semantic-lineage.js';
+import type { SemanticEditScript } from './semantic-edit-script.js';
 import type { SemanticPatchBundleRecord } from './semantic-patch-bundle.js';
+import type { BidirectionalTargetChangeSourceEditProjectionHint } from './bidirectional-target-change-source-edit.js';
 import type {
   BidirectionalTargetChangeRoundtripEvidence,
   BidirectionalTargetChangeSemanticMergeAdmissionEvidence,
@@ -19,6 +21,7 @@ import type {
 } from './bidirectional-target-change-evidence.js';
 
 export type * from './bidirectional-target-change-evidence.js';
+export type * from './bidirectional-target-change-source-edit.js';
 
 export interface CreateBidirectionalTargetChangeRecordOptions {
   readonly id?: string;
@@ -73,6 +76,8 @@ export interface BidirectionalTargetChangeRecord {
   readonly sourceAnchorMatches: readonly BidirectionalTargetChangeSourceAnchorMatch[];
   readonly targetPortability: BidirectionalTargetPortabilityRecord;
   readonly roundtripEvidence: BidirectionalTargetChangeRoundtripEvidence;
+  readonly sourceEditScript?: SemanticEditScript;
+  readonly sourceProjectionHint?: BidirectionalTargetChangeSourceEditProjectionHint;
   readonly sourcePatchBundle: SemanticPatchBundleRecord;
   readonly historyRecord: SemanticHistoryRecord;
   readonly evidence: readonly EvidenceRecord[];
@@ -88,6 +93,8 @@ export interface BidirectionalTargetChangeRecord {
     readonly sourceMapBackedMatches: number;
     readonly sourceMapLinks: number;
     readonly sourceMapMappingIds: number;
+    readonly sourceEditScripts: number;
+    readonly sourceProjectionHints: number;
     readonly lineageResolutions: number;
     readonly targetPortabilityStatus: BidirectionalTargetPortabilityStatus;
     readonly portableTargetRegions: number;
@@ -101,6 +108,9 @@ export interface BidirectionalTargetChangeRecord {
     readonly targetPortability?: BidirectionalTargetPortabilityRecord;
     readonly roundtripEvidenceId?: string;
     readonly semanticMergeAdmission?: BidirectionalTargetChangeSemanticMergeAdmissionEvidence;
+    readonly sourceEditScriptId?: string;
+    readonly sourceProjectionHintId?: string;
+    readonly sourceProjectionHint?: BidirectionalTargetChangeSourceEditProjectionHint;
     readonly [key: string]: unknown;
   };
 }

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

@@ -0,0 +1,86 @@
+export type JsTsSafeMemberMergeRegionKind = 'interface' | 'type' | 'class' | 'object';
+export type JsTsSafeMemberMergeOrder = 'non-semantic' | string;
+export type JsTsSafeMemberMergeStatus = 'merged' | 'rejected';
+
+export interface JsTsSafeMemberMergePolicyRegion {
+  readonly kind: JsTsSafeMemberMergeRegionKind | string;
+  readonly name: string;
+  readonly regionKind?: string;
+  readonly order?: JsTsSafeMemberMergeOrder;
+  readonly ordering?: JsTsSafeMemberMergeOrder;
+  readonly nonSemanticOrder?: boolean;
+  readonly orderSensitive?: boolean;
+}
+
+export interface JsTsSafeMemberMergePolicy {
+  readonly unorderedRegions?: readonly JsTsSafeMemberMergePolicyRegion[];
+  readonly unorderedMemberRegions?: readonly JsTsSafeMemberMergePolicyRegion[];
+  readonly safeList?: readonly JsTsSafeMemberMergePolicyRegion[];
+  readonly safeMembers?: readonly JsTsSafeMemberMergePolicyRegion[];
+}
+
+export interface JsTsSafeMemberMergeInput {
+  readonly baseSourceText: string;
+  readonly workerSourceText: string;
+  readonly headSourceText: string;
+  readonly policy?: JsTsSafeMemberMergePolicy | readonly JsTsSafeMemberMergePolicyRegion[];
+  readonly mergePolicy?: JsTsSafeMemberMergePolicy | readonly JsTsSafeMemberMergePolicyRegion[];
+  readonly unorderedRegions?: readonly JsTsSafeMemberMergePolicyRegion[];
+  readonly allowNonPolicySourceChanges?: boolean;
+}
+
+export interface JsTsSafeMemberMergeConflict {
+  readonly code: string;
+  readonly gateId: string;
+  readonly message: string;
+  readonly side?: 'base' | 'worker' | 'head' | string;
+  readonly sourcePath?: string;
+  readonly details?: Record<string, unknown>;
+}
+
+export interface JsTsSafeMemberMergeGate {
+  readonly id: string;
+  readonly status: 'passed' | 'blocked' | 'skipped' | string;
+  readonly reasonCodes: readonly string[];
+}
+
+export interface JsTsSafeMemberMergeAdmission {
+  readonly status: 'auto-merge-candidate' | 'blocked' | string;
+  readonly action: 'apply' | 'human-review' | string;
+  readonly reviewRequired: boolean;
+  readonly autoApplyCandidate: boolean;
+  readonly reasonCodes: readonly string[];
+}
+
+export interface JsTsSafeMemberMergedRegion {
+  readonly kind: JsTsSafeMemberMergeRegionKind;
+  readonly name: string;
+  readonly regionKind?: string;
+  readonly workerAddedKeys: readonly string[];
+  readonly headAddedKeys: readonly string[];
+}
+
+export interface JsTsSafeMemberMergeResult {
+  readonly kind: 'frontier.lang.jsTsSafeMemberMerge';
+  readonly version: 1;
+  readonly status: JsTsSafeMemberMergeStatus;
+  readonly sourceText?: string;
+  readonly reasonCodes: readonly string[];
+  readonly conflicts: readonly JsTsSafeMemberMergeConflict[];
+  readonly gates: readonly JsTsSafeMemberMergeGate[];
+  readonly admission: JsTsSafeMemberMergeAdmission;
+  readonly mergedRegions: readonly JsTsSafeMemberMergedRegion[];
+  readonly summary: {
+    readonly regions: number;
+    readonly workerAdditions: number;
+    readonly headAdditions: number;
+    readonly appliedAdditions: number;
+    readonly conflicts: number;
+  };
+  readonly metadata: {
+    readonly explicitPolicy: boolean;
+  };
+}
+
+export declare function mergeJsTsSafeMemberAdditions(input?: JsTsSafeMemberMergeInput): JsTsSafeMemberMergeResult;
+export declare function safeMergeJsTsMembers(input?: JsTsSafeMemberMergeInput): JsTsSafeMemberMergeResult;

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

@@ -0,0 +1,131 @@
+import type { FrontierSourceLanguage } from '@shapeshift-labs/frontier-lang-kernel';
+import type {
+  JsTsSafeMemberMergePolicy,
+  JsTsSafeMemberMergePolicyRegion
+} from './js-ts-safe-member-merge.js';
+
+export type JsTsSafeMergeStatus = 'merged' | 'blocked';
+export type JsTsSafeMergeGateStatus = 'passed' | 'blocked' | 'skipped';
+
+export declare const JsTsSafeMergeStatuses: Readonly<{
+  readonly merged: 'merged';
+  readonly blocked: 'blocked';
+}>;
+
+export declare const JsTsSafeMergeGateIds: Readonly<{
+  readonly parseLedger: 'parse-ledger';
+  readonly preserveBaseOrder: 'preserve-base-order';
+  readonly stableExistingDeclarations: 'stable-existing-declarations';
+  readonly independentImportSpecifiers: 'independent-import-specifiers';
+  readonly independentTopLevelDeclarations: 'independent-top-level-declarations';
+  readonly uniqueNames: 'unique-names';
+  readonly resolvedInsertionAnchors: 'resolved-insertion-anchors';
+}>;
+
+export declare const JsTsSafeMergeConflictCodes: Readonly<{
+  readonly invalidInput: 'invalid-input';
+  readonly parserLedgerLoss: 'parser-ledger-loss';
+  readonly malformedSyntax: 'malformed-syntax';
+  readonly sideEffectImportReorder: 'side-effect-import-reorder';
+  readonly topLevelOrderChanged: 'top-level-order-changed';
+  readonly changedExistingDeclaration: 'changed-existing-declaration';
+  readonly typeAliasConflict: 'type-alias-conflict';
+  readonly importShapeChanged: 'import-shape-changed';
+  readonly importSpecifierRemoved: 'import-specifier-removed';
+  readonly importSpecifierReordered: 'import-specifier-reordered';
+  readonly importFormattingChanged: 'import-formatting-changed';
+  readonly newImportDeclaration: 'new-import-declaration';
+  readonly duplicateName: 'duplicate-name';
+  readonly computedKey: 'computed-key';
+  readonly unsupportedDecorator: 'unsupported-decorator-merge-anchor';
+  readonly unsupportedOverload: 'unsupported-overload-merge-anchor';
+  readonly staleSourceHash: 'stale-source-hash';
+  readonly missingSourceLedgerSpan: 'missing-source-ledger-span';
+  readonly ambiguousInsertionPoint: 'ambiguous-insertion-point';
+  readonly insertionAnchorMissing: 'insertion-anchor-missing';
+}>;
+
+export interface JsTsSafeMergeInput {
+  readonly id?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly baseSourceText: string;
+  readonly workerSourceText: string;
+  readonly headSourceText: string;
+  readonly workerChangeSetId?: string;
+  readonly headChangeSetId?: string;
+  readonly baseHash?: string;
+  readonly workerHash?: string;
+  readonly headHash?: string;
+  readonly expectedSourceHash?: string;
+  readonly currentSourceHash?: string;
+  readonly expectedBaseHash?: string;
+  readonly expectedWorkerHash?: string;
+  readonly expectedHeadHash?: string;
+  readonly requireSourceLedgerSpans?: boolean;
+  readonly sourceLedgerSide?: 'base' | 'worker' | 'head' | string;
+  readonly sourceLedger?: unknown;
+  readonly sourceLedgers?: Record<string, unknown>;
+  readonly baseSourceLedger?: unknown;
+  readonly workerSourceLedger?: unknown;
+  readonly headSourceLedger?: unknown;
+  readonly policy?: JsTsSafeMemberMergePolicy | readonly JsTsSafeMemberMergePolicyRegion[];
+  readonly mergePolicy?: JsTsSafeMemberMergePolicy | readonly JsTsSafeMemberMergePolicyRegion[];
+  readonly unorderedRegions?: readonly JsTsSafeMemberMergePolicyRegion[];
+}
+
+export interface JsTsSafeMergeConflict {
+  readonly code: string;
+  readonly gateId: string;
+  readonly message: string;
+  readonly side?: 'base' | 'worker' | 'head' | 'merged' | string;
+  readonly sourcePath?: string;
+  readonly details?: Record<string, unknown>;
+}
+
+export interface JsTsSafeMergeGate {
+  readonly id: string;
+  readonly status: JsTsSafeMergeGateStatus;
+  readonly reasonCodes: readonly string[];
+}
+
+export interface JsTsSafeMergeAdmission {
+  readonly status: 'auto-merge-candidate' | 'blocked' | string;
+  readonly action: 'apply' | 'human-review' | string;
+  readonly reviewRequired: boolean;
+  readonly autoApplyCandidate: boolean;
+  readonly autoMergeClaim: false;
+  readonly semanticEquivalenceClaim: false;
+  readonly reasonCodes: readonly string[];
+}
+
+export interface JsTsSafeMergeSummary {
+  readonly importSpecifierAdditions: number;
+  readonly topLevelDeclarationAdditions: number;
+  readonly changedExistingDeclarations: number;
+  readonly conflicts: number;
+  readonly gatesPassed: number;
+  readonly memberRegions?: number;
+  readonly memberAdditions?: number;
+  readonly composedPhases?: number;
+}
+
+export interface JsTsSafeMergeResult {
+  readonly kind: 'frontier.lang.jsTsSafeMerge';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.jsTsSafeMerge.v1';
+  readonly id: string;
+  readonly status: JsTsSafeMergeStatus;
+  readonly sourcePath?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly mergedSourceText?: string;
+  readonly outputSourceText?: string;
+  readonly conflicts: readonly JsTsSafeMergeConflict[];
+  readonly gates: readonly JsTsSafeMergeGate[];
+  readonly admission: JsTsSafeMergeAdmission;
+  readonly summary: JsTsSafeMergeSummary;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export declare function safeMergeJsTsImportsAndDeclarations(input: JsTsSafeMergeInput): JsTsSafeMergeResult;
+export declare function safeMergeJsTsSource(input: JsTsSafeMergeInput): JsTsSafeMergeResult;

package/dist/declarations/js-ts-semantic-conflict-sidecars.d.ts

@@ -0,0 +1,235 @@
+import type {
+  FrontierSourceLanguage,
+  SemanticMergeReadiness,
+  SourceSpan
+} from '@shapeshift-labs/frontier-lang-kernel';
+
+export type JsTsSemanticConflictSidecarClass =
+  | 'same-region'
+  | 'delete-modify'
+  | 'duplicate-export'
+  | 'duplicate-member'
+  | 'ordered-list-conflict'
+  | 'parser-ledger-loss'
+  | 'stale-source-hash'
+  | 'unsupported-syntax';
+
+export type JsTsSemanticConflictSidecarSeverity = 'info' | 'warning' | 'error';
+export type JsTsSemanticConflictSidecarRisk = 'low' | 'medium' | 'high';
+
+export interface JsTsSemanticConflictAffected {
+  readonly sourcePaths: readonly string[];
+  readonly spans: readonly SourceSpan[];
+  readonly keys: readonly string[];
+  readonly regionKeys: readonly string[];
+  readonly symbolIds: readonly string[];
+  readonly symbolNames: readonly string[];
+  readonly memberKeys: readonly string[];
+  readonly exportNames: readonly string[];
+  readonly orderedListKeys: readonly string[];
+  readonly sourceHashes: readonly string[];
+}
+
+export interface JsTsSemanticConflictExplanation {
+  readonly class: JsTsSemanticConflictSidecarClass;
+  readonly severity: JsTsSemanticConflictSidecarSeverity;
+  readonly risk: JsTsSemanticConflictSidecarRisk;
+  readonly affected: JsTsSemanticConflictAffected;
+  readonly reasonCodes: readonly string[];
+  readonly suggestedOutcome: string;
+}
+
+export interface JsTsSemanticConflictSidecarRecord {
+  readonly kind: 'frontier.lang.jsTsSemanticMergeConflictSidecar';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.jsTsSemanticMergeConflictSidecar.v1';
+  readonly id: string;
+  readonly class: JsTsSemanticConflictSidecarClass;
+  readonly severity: JsTsSemanticConflictSidecarSeverity;
+  readonly risk: JsTsSemanticConflictSidecarRisk;
+  readonly readiness: SemanticMergeReadiness;
+  readonly affected: JsTsSemanticConflictAffected;
+  readonly reasonCodes: readonly string[];
+  readonly suggestedOutcome: string;
+  readonly explanation: JsTsSemanticConflictExplanation;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface JsTsSemanticConflictSidecarSummary {
+  readonly schema: 'frontier.lang.jsTsSemanticConflictSidecarSummary.v1';
+  readonly total: number;
+  readonly classes: readonly JsTsSemanticConflictSidecarClass[];
+  readonly byClass: Readonly<Record<string, number>>;
+  readonly bySeverity: Readonly<Record<string, number>>;
+  readonly byRisk: Readonly<Record<string, number>>;
+  readonly highestSeverity: JsTsSemanticConflictSidecarSeverity;
+  readonly highestRisk: JsTsSemanticConflictSidecarRisk;
+  readonly readiness: SemanticMergeReadiness;
+  readonly affectedSourcePaths: readonly string[];
+  readonly affectedKeys: readonly string[];
+  readonly reasonCodes: readonly string[];
+  readonly suggestedOutcome: string;
+}
+
+export interface JsTsSemanticConflictSidecarBundle {
+  readonly kind: 'frontier.lang.jsTsSemanticMergeConflictSidecars';
+  readonly version: 1;
+  readonly schema: 'frontier.lang.jsTsSemanticMergeConflictSidecars.v1';
+  readonly id: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly expectedSourceHash?: string;
+  readonly currentSourceHash?: string;
+  readonly conflicts: readonly JsTsSemanticConflictSidecarRecord[];
+  readonly sidecars: readonly JsTsSemanticConflictSidecarRecord[];
+  readonly summary: JsTsSemanticConflictSidecarSummary;
+  readonly admission: {
+    readonly status: SemanticMergeReadiness;
+    readonly reviewRequired: boolean;
+    readonly autoMergeSafe: boolean;
+    readonly suggestedOutcome: string;
+    readonly reasonCodes: readonly string[];
+  };
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface JsTsSemanticConflictChangeInput {
+  readonly id?: string;
+  readonly operationId?: string;
+  readonly side?: string;
+  readonly author?: string;
+  readonly branch?: string;
+  readonly source?: string;
+  readonly kind?: string;
+  readonly changeKind?: string;
+  readonly editKind?: string;
+  readonly op?: string;
+  readonly sourcePath?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly span?: SourceSpan;
+  readonly range?: SourceSpan;
+  readonly key?: string;
+  readonly conflictKey?: string;
+  readonly regionKey?: string;
+  readonly semanticKey?: string;
+  readonly anchorKey?: string;
+  readonly symbolId?: string;
+  readonly symbolName?: string;
+  readonly symbolKind?: string;
+  readonly memberName?: string;
+  readonly exportName?: string;
+  readonly containerKey?: string;
+  readonly parentKey?: string;
+  readonly listKey?: string;
+  readonly orderedListKey?: string;
+  readonly index?: number | string;
+  readonly position?: number | string;
+  readonly orderKey?: string;
+  readonly beforeKey?: string;
+  readonly afterKey?: string;
+  readonly sourceHash?: string;
+  readonly reasonCode?: string;
+  readonly reasonCodes?: readonly string[];
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface JsTsSemanticConflictDeclarationInput extends JsTsSemanticConflictChangeInput {
+  readonly name?: string;
+  readonly exported?: boolean;
+  readonly isExport?: boolean;
+  readonly member?: boolean;
+  readonly isMember?: boolean;
+}
+
+export interface JsTsSemanticConflictLossInput {
+  readonly id?: string;
+  readonly kind?: string;
+  readonly code?: string;
+  readonly category?: string;
+  readonly severity?: JsTsSemanticConflictSidecarSeverity | string;
+  readonly status?: string;
+  readonly sourcePath?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly key?: string;
+  readonly message?: string;
+  readonly summary?: string;
+  readonly reasonCode?: string;
+  readonly reasonCodes?: readonly string[];
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface JsTsSemanticConflictOrderedListInput {
+  readonly id?: string;
+  readonly key?: string;
+  readonly sourcePath?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly changes?: readonly JsTsSemanticConflictChangeInput[];
+  readonly operations?: readonly JsTsSemanticConflictChangeInput[];
+  readonly edits?: readonly JsTsSemanticConflictChangeInput[];
+}
+
+export interface CreateJsTsSemanticConflictSidecarsInput {
+  readonly id?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourceLanguage?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly path?: string;
+  readonly readiness?: SemanticMergeReadiness | string;
+  readonly expectedSourceHash?: string;
+  readonly currentSourceHash?: string;
+  readonly expectedHash?: string;
+  readonly actualSourceHash?: string;
+  readonly staleSourceHash?: boolean;
+  readonly sourceHashAssertions?: {
+    readonly expectedSourceHash?: string;
+    readonly currentSourceHash?: string;
+  };
+  readonly sourceHashes?: {
+    readonly expectedSourceHash?: string;
+    readonly currentSourceHash?: string;
+  };
+  readonly changes?: readonly JsTsSemanticConflictChangeInput[];
+  readonly operations?: readonly JsTsSemanticConflictChangeInput[];
+  readonly edits?: readonly JsTsSemanticConflictChangeInput[];
+  readonly left?: {
+    readonly changes?: readonly JsTsSemanticConflictChangeInput[];
+    readonly operations?: readonly JsTsSemanticConflictChangeInput[];
+  };
+  readonly right?: {
+    readonly changes?: readonly JsTsSemanticConflictChangeInput[];
+    readonly operations?: readonly JsTsSemanticConflictChangeInput[];
+  };
+  readonly declarations?: readonly JsTsSemanticConflictDeclarationInput[];
+  readonly exports?: readonly JsTsSemanticConflictDeclarationInput[];
+  readonly members?: readonly JsTsSemanticConflictDeclarationInput[];
+  readonly symbols?: readonly JsTsSemanticConflictDeclarationInput[];
+  readonly orderedLists?: readonly JsTsSemanticConflictOrderedListInput[];
+  readonly parserLosses?: readonly JsTsSemanticConflictLossInput[];
+  readonly ledgerLosses?: readonly JsTsSemanticConflictLossInput[];
+  readonly losses?: readonly JsTsSemanticConflictLossInput[];
+  readonly diagnostics?: readonly JsTsSemanticConflictLossInput[];
+  readonly unsupportedSyntax?: readonly JsTsSemanticConflictLossInput[];
+  readonly syntaxUnsupported?: readonly JsTsSemanticConflictLossInput[];
+  readonly syntaxLosses?: readonly JsTsSemanticConflictLossInput[];
+  readonly conflicts?: readonly Partial<JsTsSemanticConflictSidecarRecord>[];
+  readonly sidecars?: readonly Partial<JsTsSemanticConflictSidecarRecord>[];
+  readonly conflictSidecars?: readonly Partial<JsTsSemanticConflictSidecarRecord>[];
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface CreateJsTsSemanticConflictSidecarsOptions {
+  readonly id?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly readiness?: SemanticMergeReadiness | string;
+  readonly expectedSourceHash?: string;
+  readonly currentSourceHash?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export declare const JsTsSemanticConflictSidecarClasses: readonly JsTsSemanticConflictSidecarClass[];
+export declare function createJsTsSemanticConflictSidecars(input?: CreateJsTsSemanticConflictSidecarsInput, options?: CreateJsTsSemanticConflictSidecarsOptions): JsTsSemanticConflictSidecarBundle;
+export declare function summarizeJsTsSemanticConflictSidecars(records?: readonly JsTsSemanticConflictSidecarRecord[], context?: {
+  readonly sourcePath?: string;
+  readonly readiness?: SemanticMergeReadiness | string;
+}): JsTsSemanticConflictSidecarSummary;