@shapeshift-labs/frontier-lang-compiler 0.2.71 → 0.2.72

package/README.md

@@ -747,7 +747,7 @@ The published Frontier package family is generated from one shared package catal
 - [`@shapeshift-labs/frontier-lang-go`](https://www.npmjs.com/package/@shapeshift-labs/frontier-lang-go): Go source-language importer package for Frontier Lang semantic documents, including package-level metadata, Go AST adapter helpers, native import results, and semantic sidecar generation for go/ast File or Package trees.
 - [`@shapeshift-labs/frontier-lang-csharp`](https://www.npmjs.com/package/@shapeshift-labs/frontier-lang-csharp): C# Roslyn source-language importer package for Frontier Lang semantic documents, including package-level metadata, Roslyn adapter helpers, native import results, and semantic sidecar generation for SyntaxTree/SyntaxNode-shaped ASTs.
 - [`@shapeshift-labs/frontier-lang-clang`](https://www.npmjs.com/package/@shapeshift-labs/frontier-lang-clang): Clang AST source-language importer package for Frontier Lang semantic documents, including package-level metadata, Clang AST JSON adapter helpers, native import results, and semantic sidecar generation for C/C++ translation units.
-- [`@shapeshift-labs/frontier-lang-cli`](https://www.npmjs.com/package/@shapeshift-labs/frontier-lang-cli): Command line interface for parsing, checking, hashing, and emitting Frontier Lang projects.
+- [`@shapeshift-labs/frontier-lang-cli`](https://www.npmjs.com/package/@shapeshift-labs/frontier-lang-cli): Command line interface for parsing, checking, hashing, emitting, native source import/projection, semantic slicing, and corpus roundtrip evidence for Frontier Lang projects.
 - [`@shapeshift-labs/frontier-lang`](https://www.npmjs.com/package/@shapeshift-labs/frontier-lang): Umbrella package for Frontier Lang kernel, parser, checker, compiler facade, universal AST helpers, projection adapters, and source-language importer adapters.
 - [`@shapeshift-labs/frontier-kv`](https://www.npmjs.com/package/@shapeshift-labs/frontier-kv): Serializable in-memory key/value state for Frontier apps, including TTL, versioned compare-and-set, batched patch mutations, scans, watchers, snapshots, JSONL event evidence, and replay verification.
 - [`@shapeshift-labs/frontier-kv-locks`](https://www.npmjs.com/package/@shapeshift-labs/frontier-kv-locks): Lease-style lock records on top of Frontier KV, including acquire, renew, release, fencing tokens, expiration, owner evidence, and replayable lock events.

package/dist/declarations/semantic-history-records.d.ts

@@ -8,8 +8,8 @@ import type {
 export type SemanticHistoryAdmissionStatus = 'proposed' | 'queued' | 'admitted' | 'needs-review' | 'blocked' | 'rejected' | string;
 export type SemanticHistoryReviewerStatus = 'unreviewed' | 'approved' | 'changes-requested' | 'reviewed' | 'rejected' | string;
 export type SemanticHistoryReplayLinkKind = 'patch' | 'slice' | 'sidecar' | 'run' | 'proof' | 'source' | 'command' | 'url' | 'replay' | string;
-export type SemanticHistoryOverlapKind = 'ownership' | 'conflict-key' | 'source' | 'source-path' | 'import' | 'semantic-candidate' | 'semantic-claim' | 'claim-hash' | 'evidence' | 'proof' | 'replay' | 'patch' | 'merge-decision' | 'actor' | 'record-source' | 'base-hash' | 'target-hash';
-export type SemanticHistoryConflictReason = 'ownership-overlap' | 'semantic-conflict-key-overlap' | 'base-hash-mismatch' | 'target-hash-mismatch' | 'admission-blocked' | 'reviewer-rejected' | 'source-path-overlap' | string;
+export type SemanticHistoryOverlapKind = 'ownership' | 'conflict-key' | 'source' | 'source-path' | 'import' | 'semantic-candidate' | 'semantic-claim' | 'claim-hash' | 'semantic-lineage' | 'semantic-anchor' | 'crdt-operation' | 'crdt-head' | 'evidence' | 'proof' | 'replay' | 'patch' | 'merge-decision' | 'actor' | 'record-source' | 'base-hash' | 'target-hash';
+export type SemanticHistoryConflictReason = 'ownership-overlap' | 'semantic-conflict-key-overlap' | 'semantic-anchor-overlap' | 'base-hash-mismatch' | 'target-hash-mismatch' | 'admission-blocked' | 'reviewer-rejected' | 'source-path-overlap' | string;
 export type SemanticHistoryClaimKind = 'fact' | 'theory' | 'invariant' | 'semantic-claim' | string;
 export type SemanticHistoryClaimStatus = 'accepted' | 'rejected' | 'proposed' | 'superseded' | string;
 export type SemanticHistoryProofAttemptStatus = 'passed' | 'failed' | 'unknown' | 'blocked' | string;
@@ -262,6 +262,12 @@ export interface SemanticHistoryRecordIndex {
   readonly semanticClaimHashes: readonly string[];
   readonly acceptedFactIds: readonly string[];
   readonly rejectedTheoryIds: readonly string[];
+  readonly lineageEventIds: readonly string[];
+  readonly semanticAnchorIds: readonly string[];
+  readonly semanticAnchorKeys: readonly string[];
+  readonly semanticLineageKinds: readonly string[];
+  readonly crdtOperationIds: readonly string[];
+  readonly crdtHeads: readonly string[];
   readonly conflictKeys: readonly string[];
   readonly evidenceIds: readonly string[];
   readonly importedParserEvidenceIds: readonly string[];

package/dist/declarations/semantic-history.d.ts

@@ -6,6 +6,7 @@ import type {
   SourceSpan
 } from '@shapeshift-labs/frontier-lang-kernel';
 import type { SemanticImportOwnershipRegion } from './semantic-sidecar.js';
+import type { CreateSemanticLineageEventInput, SemanticLineageEvent } from './semantic-lineage.js';
 
 import type { SemanticHistoryAdmissionStatus, SemanticHistoryReviewerStatus, SemanticHistoryReplayLinkKind, SemanticHistoryOverlapKind, SemanticHistoryConflictReason, SemanticHistoryClaimKind, SemanticHistoryClaimStatus, SemanticHistoryProofAttemptStatus, SemanticHistoryMergeDecisionStatus, SemanticHistoryActorRef, SemanticHistoryRecordSourceRef, SemanticHistorySourceRef, SemanticHistoryOwnershipRegionRef, SemanticHistoryCandidateRef, SemanticHistoryClaimRecord, SemanticHistoryImportedParserEvidenceRecord, SemanticHistoryProofAttemptRecord, SemanticHistoryPatchAncestryRecord, SemanticHistoryMergeDecisionRecord, SemanticHistoryClaimInput, SemanticHistoryImportedParserEvidenceInput, SemanticHistoryProofAttemptInput, SemanticHistoryPatchAncestryInput, SemanticHistoryMergeDecisionInput, SemanticHistoryReviewerState, SemanticHistoryAdmissionState, SemanticHistoryReplayLink, SemanticHistoryRecordIndex } from './semantic-history-records.js';
 export type { SemanticHistoryAdmissionStatus, SemanticHistoryReviewerStatus, SemanticHistoryReplayLinkKind, SemanticHistoryOverlapKind, SemanticHistoryConflictReason, SemanticHistoryClaimKind, SemanticHistoryClaimStatus, SemanticHistoryProofAttemptStatus, SemanticHistoryMergeDecisionStatus, SemanticHistoryActorRef, SemanticHistoryRecordSourceRef, SemanticHistorySourceRef, SemanticHistoryOwnershipRegionRef, SemanticHistoryCandidateRef, SemanticHistoryClaimRecord, SemanticHistoryImportedParserEvidenceRecord, SemanticHistoryProofAttemptRecord, SemanticHistoryPatchAncestryRecord, SemanticHistoryMergeDecisionRecord, SemanticHistoryClaimInput, SemanticHistoryImportedParserEvidenceInput, SemanticHistoryProofAttemptInput, SemanticHistoryPatchAncestryInput, SemanticHistoryMergeDecisionInput, SemanticHistoryReviewerState, SemanticHistoryAdmissionState, SemanticHistoryReplayLink, SemanticHistoryRecordIndex } from './semantic-history-records.js';
@@ -31,6 +32,7 @@ export interface SemanticHistoryRecord {
   readonly rejectedTheories: readonly SemanticHistoryClaimRecord[];
   readonly importedParserEvidence: readonly SemanticHistoryImportedParserEvidenceRecord[];
   readonly proofAttempts: readonly SemanticHistoryProofAttemptRecord[];
+  readonly lineageEvents: readonly SemanticLineageEvent[];
   readonly patchAncestry: readonly SemanticHistoryPatchAncestryRecord[];
   readonly mergeDecisions: readonly SemanticHistoryMergeDecisionRecord[];
   readonly evidenceIds: readonly string[];
@@ -83,6 +85,9 @@ export interface CreateSemanticHistoryRecordInput {
   readonly parserEvidence?: readonly SemanticHistoryImportedParserEvidenceInput[] | SemanticHistoryImportedParserEvidenceInput;
   readonly proofAttempts?: readonly SemanticHistoryProofAttemptInput[] | SemanticHistoryProofAttemptInput;
   readonly proofs?: readonly SemanticHistoryProofAttemptInput[] | SemanticHistoryProofAttemptInput;
+  readonly lineageEvents?: readonly CreateSemanticLineageEventInput[] | CreateSemanticLineageEventInput;
+  readonly semanticLineageEvents?: readonly CreateSemanticLineageEventInput[] | CreateSemanticLineageEventInput;
+  readonly lineage?: readonly CreateSemanticLineageEventInput[] | CreateSemanticLineageEventInput;
   readonly patchAncestry?: readonly SemanticHistoryPatchAncestryInput[] | SemanticHistoryPatchAncestryInput;
   readonly patchAncestors?: readonly SemanticHistoryPatchAncestryInput[] | SemanticHistoryPatchAncestryInput;
   readonly ancestry?: readonly SemanticHistoryPatchAncestryInput[] | SemanticHistoryPatchAncestryInput;
@@ -107,6 +112,8 @@ export interface CreateSemanticHistoryRecordInput {
 export interface SemanticHistoryOverlapQueryOptions {
   readonly includeSourcePaths?: boolean;
   readonly includeClaims?: boolean;
+  readonly includeLineage?: boolean;
+  readonly includeCrdt?: boolean;
   readonly includeEvidence?: boolean;
   readonly includeProofs?: boolean;
   readonly includeReplay?: boolean;

package/dist/declarations/semantic-lineage.d.ts

@@ -0,0 +1,145 @@
+import type { FrontierSourceLanguage, SourceSpan } from '@shapeshift-labs/frontier-lang-kernel';
+
+export type SemanticLineageEventKind = 'unchanged' | 'moved' | 'renamed' | 'split' | 'merged' | 'deleted' | 'recreated' | 'unknown' | string;
+
+export interface SemanticAnchor {
+  readonly id?: string;
+  readonly key?: string;
+  readonly kind?: string;
+  readonly language?: FrontierSourceLanguage | string;
+  readonly sourcePath?: string;
+  readonly sourceHash?: string;
+  readonly symbolId?: string;
+  readonly symbolName?: string;
+  readonly semanticPath?: readonly string[];
+  readonly signatureHash?: string;
+  readonly bodyHash?: string;
+  readonly sourceSpan?: SourceSpan;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticLineageCrdtClock {
+  readonly operationId?: string;
+  readonly actor?: string;
+  readonly seq?: number;
+  readonly deps?: readonly string[];
+  readonly heads?: readonly string[];
+  readonly stateVector?: Record<string, number>;
+  readonly versionFrame?: Record<string, unknown>;
+}
+
+export interface SemanticLineageEvidence {
+  readonly pathMatch?: boolean;
+  readonly signatureHashMatch?: boolean;
+  readonly bodyHashMatch?: boolean;
+  readonly syntaxShapeMatch?: boolean;
+  readonly sourceSpanMoved?: boolean;
+  readonly confidence?: number;
+  readonly command?: string;
+}
+
+export interface SemanticLineageActor {
+  readonly id?: string;
+  readonly role?: string;
+  readonly lane?: string;
+  readonly taskId?: string;
+  readonly runId?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticLineageEvent {
+  readonly kind: 'frontier.lang.semanticLineageEvent';
+  readonly version: 1;
+  readonly id: string;
+  readonly stableId: string;
+  readonly hash: string;
+  readonly createdAt: number | string;
+  readonly eventKind: SemanticLineageEventKind;
+  readonly from?: SemanticAnchor;
+  readonly to: readonly SemanticAnchor[];
+  readonly confidence?: number;
+  readonly actor?: SemanticLineageActor;
+  readonly crdt?: SemanticLineageCrdtClock;
+  readonly evidence?: SemanticLineageEvidence;
+  readonly evidenceIds: readonly string[];
+  readonly proofIds: readonly string[];
+  readonly conflictKeys: readonly string[];
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface CreateSemanticLineageEventInput {
+  readonly id?: string;
+  readonly hash?: string;
+  readonly createdAt?: number | string;
+  readonly eventKind?: SemanticLineageEventKind;
+  readonly event?: SemanticLineageEventKind;
+  readonly kind?: SemanticLineageEventKind;
+  readonly from?: SemanticAnchor | string;
+  readonly fromAnchor?: SemanticAnchor | string;
+  readonly before?: SemanticAnchor | string;
+  readonly to?: readonly (SemanticAnchor | string)[] | SemanticAnchor | string;
+  readonly toAnchors?: readonly (SemanticAnchor | string)[] | SemanticAnchor | string;
+  readonly after?: readonly (SemanticAnchor | string)[] | SemanticAnchor | string;
+  readonly confidence?: number;
+  readonly actor?: SemanticLineageActor | string;
+  readonly actorId?: string;
+  readonly actorRole?: string;
+  readonly crdt?: SemanticLineageCrdtClock;
+  readonly clock?: SemanticLineageCrdtClock;
+  readonly operation?: SemanticLineageCrdtClock;
+  readonly operationId?: string;
+  readonly seq?: number;
+  readonly deps?: readonly string[] | string;
+  readonly heads?: readonly string[] | string;
+  readonly stateVector?: Record<string, number>;
+  readonly versionFrame?: Record<string, unknown>;
+  readonly evidence?: SemanticLineageEvidence | readonly { readonly id?: string }[];
+  readonly pathMatch?: boolean;
+  readonly signatureHashMatch?: boolean;
+  readonly bodyHashMatch?: boolean;
+  readonly syntaxShapeMatch?: boolean;
+  readonly sourceSpanMoved?: boolean;
+  readonly command?: string;
+  readonly evidenceIds?: readonly string[] | string;
+  readonly proofIds?: readonly string[] | string;
+  readonly proofs?: readonly { readonly id?: string }[];
+  readonly conflictKey?: string;
+  readonly conflictKeys?: readonly string[] | string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+export interface SemanticLineageMap {
+  readonly kind: 'frontier.lang.semanticLineageMap';
+  readonly version: 1;
+  readonly id: string;
+  readonly generatedAt: number | string;
+  readonly events: readonly SemanticLineageEvent[];
+  readonly byAnchorKey: Readonly<Record<string, readonly string[]>>;
+  readonly byEventKind: Readonly<Record<string, readonly string[]>>;
+  readonly byOperationId: Readonly<Record<string, readonly string[]>>;
+  readonly bySourcePath: Readonly<Record<string, readonly string[]>>;
+  readonly summary: {
+    readonly eventCount: number;
+    readonly anchorCount: number;
+    readonly operationCount: number;
+    readonly eventKinds: readonly string[];
+  };
+}
+
+export interface SemanticLineageQuery {
+  readonly eventKind?: SemanticLineageEventKind | readonly string[];
+  readonly anchorKey?: string | readonly string[];
+  readonly fromKey?: string | readonly string[];
+  readonly toKey?: string | readonly string[];
+  readonly sourcePath?: string | readonly string[];
+  readonly operationId?: string | readonly string[];
+  readonly head?: string | readonly string[];
+  readonly conflictKey?: string | readonly string[];
+  readonly evidenceId?: string | readonly string[];
+}
+
+export declare const SemanticLineageEventKinds: readonly SemanticLineageEventKind[];
+export declare function createSemanticAnchor(input?: SemanticAnchor | string, defaults?: Partial<SemanticAnchor>): SemanticAnchor | undefined;
+export declare function createSemanticLineageEvent(input?: CreateSemanticLineageEventInput, options?: { readonly id?: string; readonly createdAt?: number | string; readonly actor?: SemanticLineageActor | string; readonly actorId?: string; readonly actorRole?: string }): SemanticLineageEvent;
+export declare function createSemanticLineageMap(events?: readonly (SemanticLineageEvent | CreateSemanticLineageEventInput)[], options?: { readonly id?: string; readonly generatedAt?: number | string }): SemanticLineageMap;
+export declare function querySemanticLineageEvents(events: SemanticLineageEvent | readonly SemanticLineageEvent[], query?: SemanticLineageQuery): readonly SemanticLineageEvent[];

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export * from './declarations/source-preservation.js';
 export * from './declarations/semantic-sidecar-admission.js';
 export * from './declarations/semantic-merge-candidates.js';
 export * from './declarations/semantic-merge-conflicts.js';
+export * from './declarations/semantic-lineage.js';
 export * from './declarations/semantic-history.js';
 export * from './declarations/semantic-patch-bundle.js';
 export * from './declarations/semantic-impact.js';

package/dist/index.js

@@ -68,6 +68,7 @@ export { createSemanticPatchBundleRecord, querySemanticPatchBundleRecords, Seman
 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 { queryUniversalConversionPlan } from './internal/index-impl/queryUniversalConversionPlan.js';
+export { createSemanticAnchor, createSemanticLineageEvent, createSemanticLineageMap, querySemanticLineageEvents, SemanticLineageEventKinds } from './internal/index-impl/semanticLineageRecords.js';
 export { createSemanticHistoryRecord, querySemanticHistoryRecordOverlaps, SemanticHistoryAdmissionStatuses, SemanticHistoryConflictReasons, SemanticHistoryOverlapKinds, SemanticHistoryReviewerStatuses, semanticHistoryRecordsConflict, semanticHistoryRecordsOverlap } from './internal/index-impl/semanticHistoryRecords.js';
 export { readSemanticSliceJson } from './internal/index-impl/readSemanticSliceJson.js';
 export { readUniversalAstJson } from './internal/index-impl/readUniversalAstJson.js';

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

@@ -32,6 +32,10 @@ function semanticHistoryOverlap(left,right,options){
     'semantic-candidate':intersect(leftIndex.semanticCandidateIds,rightIndex.semanticCandidateIds),
     'semantic-claim':options.includeClaims?intersect(leftIndex.semanticClaimIds,rightIndex.semanticClaimIds):[],
     'claim-hash':options.includeClaims?intersect(leftIndex.semanticClaimHashes,rightIndex.semanticClaimHashes):[],
+    'semantic-lineage':options.includeLineage?intersect(leftIndex.lineageEventIds,rightIndex.lineageEventIds):[],
+    'semantic-anchor':intersect(leftIndex.semanticAnchorKeys,rightIndex.semanticAnchorKeys),
+    'crdt-operation':options.includeCrdt?intersect(leftIndex.crdtOperationIds,rightIndex.crdtOperationIds):[],
+    'crdt-head':options.includeCrdt?intersect(leftIndex.crdtHeads,rightIndex.crdtHeads):[],
     evidence:options.includeEvidence?intersect(leftIndex.evidenceIds,rightIndex.evidenceIds):[],
     proof:options.includeProofs?intersect(leftIndex.proofIds,rightIndex.proofIds):[],
     replay:options.includeReplay?intersect(leftIndex.replayIds,rightIndex.replayIds):[],
@@ -43,10 +47,11 @@ function semanticHistoryOverlap(left,right,options){
     'target-hash':options.includeTargetHashes?intersect(leftIndex.targetHashes,rightIndex.targetHashes):[]
   });
   const overlapKinds=Object.keys(overlap);
-  const semanticOverlap=Boolean(overlap.ownership?.length||overlap['conflict-key']?.length||overlap.source?.length||overlap['source-path']?.length||overlap.import?.length);
+  const semanticOverlap=Boolean(overlap.ownership?.length||overlap['conflict-key']?.length||overlap['semantic-anchor']?.length||overlap.source?.length||overlap['source-path']?.length||overlap.import?.length);
   const conflictReasons=uniqueStrings([
     overlap.ownership?.length?'ownership-overlap':undefined,
     overlap['conflict-key']?.length?'semantic-conflict-key-overlap':undefined,
+    overlap['semantic-anchor']?.length?'semantic-anchor-overlap':undefined,
     semanticOverlap&&disjointNonEmpty(leftIndex.baseHashes,rightIndex.baseHashes)?'base-hash-mismatch':undefined,
     (overlap.ownership?.length||overlap['conflict-key']?.length)&&disjointNonEmpty(leftIndex.targetHashes,rightIndex.targetHashes)?'target-hash-mismatch':undefined,
     semanticOverlap&&(blockedAdmission(left)||blockedAdmission(right))?'admission-blocked':undefined,
@@ -71,6 +76,7 @@ function historyIndex(record){
   const rejectedTheories=record?.rejectedTheories??[];
   const importedParserEvidence=record?.importedParserEvidence??[];
   const proofAttempts=record?.proofAttempts??[];
+  const lineageEvents=record?.lineageEvents??[];
   const patchAncestry=record?.patchAncestry??[];
   const mergeDecisions=record?.mergeDecisions??[];
   return record?.index??{
@@ -88,11 +94,21 @@ function historyIndex(record){
     semanticClaimHashes:uniqueStrings([...acceptedFacts.map((claim)=>claim.hash),...rejectedTheories.map((claim)=>claim.hash)]),
     acceptedFactIds:uniqueStrings(acceptedFacts.map((claim)=>claim.id)),
     rejectedTheoryIds:uniqueStrings(rejectedTheories.map((claim)=>claim.id)),
-    conflictKeys:uniqueStrings([...(record?.semanticCandidates??[]).flatMap((candidate)=>candidate.conflictKeys??[]),...acceptedFacts.flatMap((claim)=>claim.conflictKeys??[]),...rejectedTheories.flatMap((claim)=>claim.conflictKeys??[]),...patchAncestry.flatMap((patch)=>patch.conflictKeys??[]),...mergeDecisions.flatMap((decision)=>decision.conflictKeys??[])]),
-    evidenceIds:uniqueStrings([...(record?.evidenceIds??[]),...acceptedFacts.flatMap((claim)=>claim.evidenceIds??[]),...rejectedTheories.flatMap((claim)=>claim.evidenceIds??[]),...importedParserEvidence.flatMap((entry)=>[entry.evidenceId,...(entry.evidenceIds??[])]),...proofAttempts.flatMap((entry)=>entry.evidenceIds??[]),...mergeDecisions.flatMap((entry)=>entry.evidenceIds??[])]),
+    lineageEventIds:uniqueStrings(lineageEvents.map((entry)=>entry.id)),
+    semanticAnchorIds:uniqueStrings(lineageEvents.flatMap((entry)=>[entry.from?.id,...(entry.to??[]).map((anchor)=>anchor.id)])),
+    semanticAnchorKeys:uniqueStrings([
+      ...lineageEvents.flatMap((entry)=>[entry.from?.key,...(entry.to??[]).map((anchor)=>anchor.key)]),
+      ...(record?.ownershipRegions??[]).map((region)=>region.key),
+      ...(record?.semanticCandidates??[]).flatMap((candidate)=>candidate.ownershipKeys??[])
+    ]),
+    semanticLineageKinds:uniqueStrings(lineageEvents.map((entry)=>entry.eventKind)),
+    crdtOperationIds:uniqueStrings(lineageEvents.map((entry)=>entry.crdt?.operationId)),
+    crdtHeads:uniqueStrings(lineageEvents.flatMap((entry)=>entry.crdt?.heads??[])),
+    conflictKeys:uniqueStrings([...(record?.semanticCandidates??[]).flatMap((candidate)=>candidate.conflictKeys??[]),...acceptedFacts.flatMap((claim)=>claim.conflictKeys??[]),...rejectedTheories.flatMap((claim)=>claim.conflictKeys??[]),...lineageEvents.flatMap((entry)=>entry.conflictKeys??[]),...patchAncestry.flatMap((patch)=>patch.conflictKeys??[]),...mergeDecisions.flatMap((decision)=>decision.conflictKeys??[])]),
+    evidenceIds:uniqueStrings([...(record?.evidenceIds??[]),...acceptedFacts.flatMap((claim)=>claim.evidenceIds??[]),...rejectedTheories.flatMap((claim)=>claim.evidenceIds??[]),...importedParserEvidence.flatMap((entry)=>[entry.evidenceId,...(entry.evidenceIds??[])]),...proofAttempts.flatMap((entry)=>entry.evidenceIds??[]),...lineageEvents.flatMap((entry)=>entry.evidenceIds??[]),...mergeDecisions.flatMap((entry)=>entry.evidenceIds??[])]),
     importedParserEvidenceIds:uniqueStrings(importedParserEvidence.map((entry)=>entry.id)),
     importedParserEvidenceHashes:uniqueStrings(importedParserEvidence.map((entry)=>entry.hash)),
-    proofIds:uniqueStrings([...(record?.proofIds??[]),...acceptedFacts.flatMap((claim)=>claim.proofIds??[]),...rejectedTheories.flatMap((claim)=>claim.proofIds??[]),...proofAttempts.flatMap((entry)=>[entry.proofId,...(entry.proofIds??[])]),...mergeDecisions.flatMap((entry)=>entry.proofIds??[])]),
+    proofIds:uniqueStrings([...(record?.proofIds??[]),...acceptedFacts.flatMap((claim)=>claim.proofIds??[]),...rejectedTheories.flatMap((claim)=>claim.proofIds??[]),...proofAttempts.flatMap((entry)=>[entry.proofId,...(entry.proofIds??[])]),...lineageEvents.flatMap((entry)=>entry.proofIds??[]),...mergeDecisions.flatMap((entry)=>entry.proofIds??[])]),
     proofAttemptIds:uniqueStrings(proofAttempts.map((entry)=>entry.id)),
     proofAttemptHashes:uniqueStrings(proofAttempts.map((entry)=>entry.hash)),
     replayIds:uniqueStrings([...(record?.replayLinks??[]).map((link)=>link.id),...(record?.semanticCandidates??[]).flatMap((candidate)=>candidate.replayIds??[]),...acceptedFacts.flatMap((claim)=>claim.replayIds??[]),...rejectedTheories.flatMap((claim)=>claim.replayIds??[]),...proofAttempts.flatMap((entry)=>entry.replayIds??[])]),

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

@@ -1,11 +1,12 @@
 import{hashSemanticValue}from'@shapeshift-labs/frontier-lang-kernel';
 import{ idFragment, maxSemanticMergeReadiness, normalizeSemanticMergeReadiness, uniqueStrings as uniqueRawStrings }from'../../native-import-utils.js';
 import{normalizeOwnershipRegions,normalizeSemanticCandidates,normalizeSemanticClaims,normalizeSources,semanticClaimsByStatus}from'./semanticHistoryRecordNormalizers.js';
+import{createSemanticLineageEvent,semanticLineageIndex}from'./semanticLineageRecords.js';
 
 export const SemanticHistoryAdmissionStatuses=Object.freeze(['proposed','queued','admitted','needs-review','blocked','rejected']);
 export const SemanticHistoryReviewerStatuses=Object.freeze(['unreviewed','approved','changes-requested','reviewed','rejected']);
-export const SemanticHistoryOverlapKinds=Object.freeze(['ownership','conflict-key','source','source-path','import','semantic-candidate','semantic-claim','claim-hash','evidence','proof','replay','patch','merge-decision','actor','record-source','base-hash','target-hash']);
-export const SemanticHistoryConflictReasons=Object.freeze(['ownership-overlap','semantic-conflict-key-overlap','base-hash-mismatch','target-hash-mismatch','admission-blocked','reviewer-rejected','source-path-overlap']);
+export const SemanticHistoryOverlapKinds=Object.freeze(['ownership','conflict-key','source','source-path','import','semantic-candidate','semantic-claim','claim-hash','semantic-lineage','semantic-anchor','crdt-operation','crdt-head','evidence','proof','replay','patch','merge-decision','actor','record-source','base-hash','target-hash']);
+export const SemanticHistoryConflictReasons=Object.freeze(['ownership-overlap','semantic-conflict-key-overlap','semantic-anchor-overlap','base-hash-mismatch','target-hash-mismatch','admission-blocked','reviewer-rejected','source-path-overlap']);
 
 export function createSemanticHistoryRecord(input={},options={}){
   const imported=input.importResult??input.imported;
@@ -36,18 +37,20 @@ export function createSemanticHistoryRecord(input={},options={}){
   const proofAttempts=normalizeProofAttempts([...(array(input.proofAttempts)),...(array(input.proofs))],sourceContext);
   const patchAncestry=normalizePatchAncestry(input.patchAncestry??input.patchAncestors??input.ancestry,sourceContext);
   const mergeDecisions=normalizeMergeDecisions(input.mergeDecisions??input.decisions,sourceContext);
+  const lineageEvents=normalizeLineageEvents(input.lineageEvents??input.semanticLineageEvents??input.lineage,sourceContext);
+  const lineage=semanticLineageIndex(lineageEvents);
   const semanticClaimIds=uniqueStrings([...acceptedFacts.map((claim)=>claim.id),...rejectedTheories.map((claim)=>claim.id)]);
   const semanticClaimHashes=uniqueStrings([...acceptedFacts.map((claim)=>claim.hash),...rejectedTheories.map((claim)=>claim.hash)]);
-  const evidenceIds=uniqueStrings([...(strings(input.evidenceIds)),...(array(input.evidence)).map((record)=>record?.id),...(array(imported?.evidence)).map((record)=>record?.id),...semanticCandidates.flatMap((candidate)=>candidate.evidenceIds),...acceptedFacts.flatMap((claim)=>claim.evidenceIds),...rejectedTheories.flatMap((claim)=>claim.evidenceIds),...importedParserEvidence.flatMap((record)=>[record.evidenceId,...array(record.evidenceIds)]),...proofAttempts.flatMap((record)=>record.evidenceIds),...mergeDecisions.flatMap((decision)=>decision.evidenceIds),...(strings(input.reviewer?.evidenceIds)),...(strings(input.admission?.evidenceIds))]);
-  const proofIds=uniqueStrings([...(strings(input.proofIds)),...(array(input.proofs)).map((record)=>record?.id),...semanticCandidates.flatMap((candidate)=>candidate.proofIds),...acceptedFacts.flatMap((claim)=>claim.proofIds),...rejectedTheories.flatMap((claim)=>claim.proofIds),...proofAttempts.flatMap((record)=>[record.proofId,...array(record.proofIds)]),...mergeDecisions.flatMap((decision)=>decision.proofIds)]);
+  const evidenceIds=uniqueStrings([...(strings(input.evidenceIds)),...(array(input.evidence)).map((record)=>record?.id),...(array(imported?.evidence)).map((record)=>record?.id),...semanticCandidates.flatMap((candidate)=>candidate.evidenceIds),...acceptedFacts.flatMap((claim)=>claim.evidenceIds),...rejectedTheories.flatMap((claim)=>claim.evidenceIds),...importedParserEvidence.flatMap((record)=>[record.evidenceId,...array(record.evidenceIds)]),...proofAttempts.flatMap((record)=>record.evidenceIds),...lineageEvents.flatMap((record)=>record.evidenceIds),...mergeDecisions.flatMap((decision)=>decision.evidenceIds),...(strings(input.reviewer?.evidenceIds)),...(strings(input.admission?.evidenceIds))]);
+  const proofIds=uniqueStrings([...(strings(input.proofIds)),...(array(input.proofs)).map((record)=>record?.id),...semanticCandidates.flatMap((candidate)=>candidate.proofIds),...acceptedFacts.flatMap((claim)=>claim.proofIds),...rejectedTheories.flatMap((claim)=>claim.proofIds),...proofAttempts.flatMap((record)=>[record.proofId,...array(record.proofIds)]),...lineageEvents.flatMap((record)=>record.proofIds),...mergeDecisions.flatMap((decision)=>decision.proofIds)]);
   const sourceIds=uniqueStrings([input.sourceId,...strings(input.sourceIds),...sources.map((source)=>source.id)]);
   const importIds=uniqueStrings([input.importId,input.importResultId,imported?.id,...strings(input.importIds),...sources.map((source)=>source.importId),...semanticCandidates.map((candidate)=>candidate.importResultId)]);
   const sourcePaths=uniqueStrings([input.sourcePath,imported?.sourcePath,...sources.map((source)=>source.sourcePath),...ownershipRegions.map((region)=>region.sourcePath),...semanticCandidates.map((candidate)=>candidate.sourcePath)]);
   const sourceHashes=uniqueStrings([input.sourceHash,imported?.sourceHash,...sources.map((source)=>source.sourceHash),...ownershipRegions.map((region)=>region.sourceHash)]);
-  const conflictKeys=uniqueStrings([...(strings(input.conflictKeys)),...semanticCandidates.flatMap((candidate)=>candidate.conflictKeys),...acceptedFacts.flatMap((claim)=>claim.conflictKeys),...rejectedTheories.flatMap((claim)=>claim.conflictKeys),...patchAncestry.flatMap((patch)=>patch.conflictKeys),...mergeDecisions.flatMap((decision)=>decision.conflictKeys)]);
+  const conflictKeys=uniqueStrings([...(strings(input.conflictKeys)),...semanticCandidates.flatMap((candidate)=>candidate.conflictKeys),...acceptedFacts.flatMap((claim)=>claim.conflictKeys),...rejectedTheories.flatMap((claim)=>claim.conflictKeys),...lineageEvents.flatMap((event)=>event.conflictKeys),...patchAncestry.flatMap((patch)=>patch.conflictKeys),...mergeDecisions.flatMap((decision)=>decision.conflictKeys)]);
   const reviewer=normalizeReviewer(input.reviewer);
   const admission=normalizeAdmission(input.admission,semanticCandidates,reviewer);
-  const actorIds=uniqueStrings([actor?.id,actor?.actorId,...acceptedFacts.map((claim)=>claim.actor?.id),...rejectedTheories.map((claim)=>claim.actor?.id),...importedParserEvidence.map((record)=>record.actor?.id),...proofAttempts.map((record)=>record.actor?.id),...patchAncestry.map((record)=>record.actor?.id),...mergeDecisions.map((record)=>record.actor?.id)]);
+  const actorIds=uniqueStrings([actor?.id,actor?.actorId,...acceptedFacts.map((claim)=>claim.actor?.id),...rejectedTheories.map((claim)=>claim.actor?.id),...importedParserEvidence.map((record)=>record.actor?.id),...proofAttempts.map((record)=>record.actor?.id),...lineageEvents.map((record)=>record.actor?.id),...patchAncestry.map((record)=>record.actor?.id),...mergeDecisions.map((record)=>record.actor?.id)]);
   const recordSourceIds=uniqueStrings([recordSource?.id,recordSource?.sourceId,...acceptedFacts.flatMap((claim)=>[claim.recordSource?.id,claim.recordSource?.sourceId]),...rejectedTheories.flatMap((claim)=>[claim.recordSource?.id,claim.recordSource?.sourceId]),...importedParserEvidence.flatMap((record)=>[record.recordSource?.id,record.recordSource?.sourceId]),...proofAttempts.flatMap((record)=>[record.recordSource?.id,record.recordSource?.sourceId]),...patchAncestry.flatMap((record)=>[record.recordSource?.id,record.recordSource?.sourceId]),...mergeDecisions.flatMap((record)=>[record.recordSource?.id,record.recordSource?.sourceId])]);
   const patchIds=uniqueStrings([...semanticCandidates.map((candidate)=>candidate.patchId),...patchAncestry.flatMap((patch)=>[patch.patchId,...array(patch.parentPatchIds),...array(patch.ancestorPatchIds)]),...mergeDecisions.flatMap((decision)=>decision.patchIds)]);
   const mergeDecisionIds=uniqueStrings(mergeDecisions.map((decision)=>decision.id));
@@ -66,6 +69,12 @@ export function createSemanticHistoryRecord(input={},options={}){
     semanticClaimHashes,
     acceptedFactIds:uniqueStrings(acceptedFacts.map((claim)=>claim.id)),
     rejectedTheoryIds:uniqueStrings(rejectedTheories.map((claim)=>claim.id)),
+    lineageEventIds:lineage.lineageEventIds,
+    semanticAnchorIds:lineage.semanticAnchorIds,
+    semanticAnchorKeys:uniqueStrings([...lineage.semanticAnchorKeys,...ownershipRegions.map((region)=>region.key),...semanticCandidates.flatMap((candidate)=>candidate.ownershipKeys)]),
+    semanticLineageKinds:lineage.semanticLineageKinds,
+    crdtOperationIds:lineage.crdtOperationIds,
+    crdtHeads:lineage.crdtHeads,
     conflictKeys,
     evidenceIds,
     importedParserEvidenceIds:uniqueStrings(importedParserEvidence.map((record)=>record.id)),
@@ -97,6 +106,7 @@ export function createSemanticHistoryRecord(input={},options={}){
     rejectedTheories,
     importedParserEvidence,
     proofAttempts,
+    lineageEvents,
     patchAncestry,
     mergeDecisions,
     evidenceIds,
@@ -170,6 +180,19 @@ function normalizeProofAttempts(records,defaults){
   });
 }
 
+function normalizeLineageEvents(records,defaults){
+  return array(records).filter(Boolean).map((record)=>createSemanticLineageEvent(record,{
+    id:record.id,
+    createdAt:record.createdAt,
+    actor:record.actor??defaults.actor,
+    actorId:record.actorId??defaults.actor?.id
+  })).map((record)=>({
+    ...record,
+    from:record.from?{...record.from,language:record.from.language??defaults.language,sourcePath:record.from.sourcePath??defaults.sourcePath,sourceHash:record.from.sourceHash??defaults.sourceHash}:record.from,
+    to:record.to.map((anchor)=>({...anchor,language:anchor.language??defaults.language,sourcePath:anchor.sourcePath??defaults.sourcePath,sourceHash:anchor.sourceHash??defaults.sourceHash}))
+  }));
+}
+
 function normalizePatchAncestry(records,defaults){
   return array(records).filter(Boolean).map((record,index)=>{
     const source=typeof record==='string'?{patchId:record}:record;

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

@@ -0,0 +1,193 @@
+import { hashSemanticValue } from '@shapeshift-labs/frontier-lang-kernel';
+import { idFragment, uniqueStrings as uniqueRawStrings } from '../../native-import-utils.js';
+
+export const SemanticLineageEventKinds = Object.freeze(['unchanged', 'moved', 'renamed', 'split', 'merged', 'deleted', 'recreated', 'unknown']);
+
+export function createSemanticAnchor(input = {}, defaults = {}) {
+  const source = typeof input === 'string' ? { key: input } : input;
+  const semanticPath = array(source.semanticPath ?? source.pathSegments).map((part) => String(part));
+  const key = firstString(source.key, source.ownershipKey, source.conflictKey, source.semanticKey, semanticPath.join('.'), source.symbolName, source.id);
+  const anchor = compactRecord({
+    id: source.id ?? (key ? `semantic_anchor_${idFragment(key)}` : undefined),
+    key,
+    kind: source.kind ?? source.anchorKind ?? source.regionKind ?? source.symbolKind,
+    language: source.language ?? defaults.language,
+    sourcePath: source.sourcePath ?? defaults.sourcePath,
+    sourceHash: source.sourceHash ?? source.hash ?? defaults.sourceHash,
+    symbolId: source.symbolId,
+    symbolName: source.symbolName ?? source.name,
+    semanticPath,
+    signatureHash: source.signatureHash,
+    bodyHash: source.bodyHash,
+    sourceSpan: source.sourceSpan ?? source.span,
+    metadata: source.metadata
+  });
+  return nonEmptyRecord(anchor);
+}
+
+export function createSemanticLineageEvent(input = {}, options = {}) {
+  const from = createSemanticAnchor(input.from ?? input.fromAnchor ?? input.before, input);
+  const toAnchors = array(input.to ?? input.toAnchors ?? input.after).map((anchor) => createSemanticAnchor(anchor, input)).filter(Boolean);
+  const eventKind = normalizeEventKind(input.eventKind ?? input.event ?? input.kind);
+  const actor = normalizeActor(input.actor ?? options.actor ?? {
+    id: input.actorId ?? options.actorId,
+    role: input.actorRole ?? options.actorRole
+  });
+  const crdt = normalizeCrdtClock(input.crdt ?? input.clock ?? input.operation ?? input);
+  const evidence = compactRecord({
+    pathMatch: input.evidence?.pathMatch ?? input.pathMatch,
+    signatureHashMatch: input.evidence?.signatureHashMatch ?? input.signatureHashMatch,
+    bodyHashMatch: input.evidence?.bodyHashMatch ?? input.bodyHashMatch,
+    syntaxShapeMatch: input.evidence?.syntaxShapeMatch ?? input.syntaxShapeMatch,
+    sourceSpanMoved: input.evidence?.sourceSpanMoved ?? input.sourceSpanMoved,
+    confidence: input.evidence?.confidence ?? input.confidence,
+    command: input.evidence?.command ?? input.command
+  });
+  const core = {
+    kind: 'frontier.lang.semanticLineageEvent',
+    version: 1,
+    eventKind,
+    from,
+    to: toAnchors,
+    confidence: clampConfidence(input.confidence),
+    actor,
+    crdt,
+    evidence,
+    evidenceIds: uniqueStrings([...(strings(input.evidenceIds)), ...(array(input.evidence)).map((entry) => entry?.id)]),
+    proofIds: uniqueStrings([...(strings(input.proofIds)), ...(array(input.proofs)).map((entry) => entry?.id)]),
+    conflictKeys: uniqueStrings([
+      ...(strings(input.conflictKeys)),
+      input.conflictKey,
+      from?.key,
+      ...toAnchors.map((anchor) => anchor.key)
+    ]),
+    metadata: compactRecord(input.metadata)
+  };
+  const hash = input.hash ?? hashSemanticValue(core);
+  return {
+    ...core,
+    id: input.id ?? options.id ?? `semantic_lineage_${idFragment(firstString(from?.key, toAnchors[0]?.key, crdt.operationId, hash))}`,
+    stableId: `semantic_lineage_${idFragment(hash)}`,
+    hash,
+    createdAt: input.createdAt ?? options.createdAt ?? Date.now()
+  };
+}
+
+export function createSemanticLineageMap(events = [], options = {}) {
+  const records = array(events).map((event) => event?.kind === 'frontier.lang.semanticLineageEvent' ? event : createSemanticLineageEvent(event, options));
+  const byAnchorKey = {};
+  const byEventKind = {};
+  const byOperationId = {};
+  const bySourcePath = {};
+  for (const event of records) {
+    indexPush(byEventKind, event.eventKind, event.id);
+    indexPush(byOperationId, event.crdt?.operationId, event.id);
+    for (const anchor of [event.from, ...event.to].filter(Boolean)) {
+      indexPush(byAnchorKey, anchor.key, event.id);
+      indexPush(bySourcePath, anchor.sourcePath, event.id);
+    }
+  }
+  return {
+    kind: 'frontier.lang.semanticLineageMap',
+    version: 1,
+    id: options.id ?? `semantic_lineage_map_${idFragment(hashSemanticValue(records.map((event) => event.id)))}`,
+    generatedAt: options.generatedAt ?? Date.now(),
+    events: records,
+    byAnchorKey,
+    byEventKind,
+    byOperationId,
+    bySourcePath,
+    summary: {
+      eventCount: records.length,
+      anchorCount: Object.keys(byAnchorKey).length,
+      operationCount: Object.keys(byOperationId).length,
+      eventKinds: Object.keys(byEventKind)
+    }
+  };
+}
+
+export function querySemanticLineageEvents(events, query = {}) {
+  return array(events).filter((event) => {
+    const record = event?.kind === 'frontier.lang.semanticLineageEvent' ? event : createSemanticLineageEvent(event);
+    const anchors = [record.from, ...record.to].filter(Boolean);
+    return matchAny(query.eventKind, [record.eventKind])
+      && matchAny(query.anchorKey, anchors.map((anchor) => anchor.key))
+      && matchAny(query.fromKey, [record.from?.key])
+      && matchAny(query.toKey, record.to.map((anchor) => anchor.key))
+      && matchAny(query.sourcePath, anchors.map((anchor) => anchor.sourcePath))
+      && matchAny(query.operationId, [record.crdt?.operationId])
+      && matchAny(query.head, record.crdt?.heads)
+      && matchAny(query.conflictKey, record.conflictKeys)
+      && matchAny(query.evidenceId, record.evidenceIds);
+  });
+}
+
+export function semanticLineageIndex(events) {
+  const records = array(events).filter(Boolean);
+  const anchors = records.flatMap((event) => [event.from, ...(event.to ?? [])]).filter(Boolean);
+  return {
+    lineageEventIds: uniqueStrings(records.map((event) => event.id)),
+    semanticAnchorIds: uniqueStrings(anchors.map((anchor) => anchor.id)),
+    semanticAnchorKeys: uniqueStrings(anchors.map((anchor) => anchor.key)),
+    semanticLineageKinds: uniqueStrings(records.map((event) => event.eventKind)),
+    crdtOperationIds: uniqueStrings(records.map((event) => event.crdt?.operationId)),
+    crdtHeads: uniqueStrings(records.flatMap((event) => event.crdt?.heads ?? []))
+  };
+}
+
+function normalizeCrdtClock(source) {
+  return nonEmptyRecord(compactRecord({
+    operationId: source.operationId ?? source.id,
+    actor: source.actorId ?? source.actor,
+    seq: source.seq,
+    deps: uniqueStrings(source.deps),
+    heads: uniqueStrings(source.heads),
+    stateVector: source.stateVector,
+    versionFrame: source.versionFrame ?? source.frame
+  }));
+}
+
+function normalizeActor(value) {
+  const actor = typeof value === 'string' ? { id: value } : value;
+  return nonEmptyRecord(compactRecord({
+    id: actor?.id ?? actor?.actorId,
+    role: actor?.role,
+    lane: actor?.lane,
+    taskId: actor?.taskId,
+    runId: actor?.runId,
+    metadata: actor?.metadata
+  }));
+}
+
+function normalizeEventKind(kind) {
+  const text = String(kind ?? 'unknown');
+  return SemanticLineageEventKinds.includes(text) ? text : text;
+}
+
+function clampConfidence(value) {
+  if (value === undefined || value === null || value === '') return undefined;
+  const number = Number(value);
+  if (!Number.isFinite(number)) return undefined;
+  return Math.max(0, Math.min(1, number));
+}
+
+function indexPush(index, key, id) {
+  if (!key || !id) return;
+  const value = String(key);
+  if (!index[value]) index[value] = [];
+  if (!index[value].includes(id)) index[value].push(id);
+}
+
+function matchAny(queryValue, values) {
+  const queries = strings(queryValue);
+  if (queries.length === 0) return true;
+  const valueSet = new Set(strings(values));
+  return queries.some((query) => valueSet.has(query));
+}
+
+function array(value) { return value === undefined || value === null ? [] : Array.isArray(value) ? value : [value]; }
+function strings(value) { return array(value).map((entry) => String(entry ?? '')).filter(Boolean); }
+function uniqueStrings(values) { return uniqueRawStrings(strings(values)); }
+function firstString(...values) { return values.map((value) => value === undefined || value === null ? '' : String(value)).find(Boolean); }
+function compactRecord(value) { return Object.fromEntries(Object.entries(value ?? {}).filter(([, entry]) => entry !== undefined && (!Array.isArray(entry) || entry.length > 0))); }
+function nonEmptyRecord(value) { return Object.keys(value ?? {}).length ? value : undefined; }

package/dist/native-region-scanner-js-helpers.js

@@ -176,7 +176,7 @@ function jsObjectPropertyDeclaration(input, lineNumber, trimmed, context) {
 
 function jsRouteRecordDeclaration(input, lineNumber, trimmed, context) {
   if (context.regionKind !== 'route') return undefined;
-  const match = trimmed.match(/\b(?:path|route|href|url)\s*:\s*(['"`])([^'"`]+)\1/);
+  const match = trimmed.match(/^(?:\{\s*)?(?:path|route|href|url)\s*:\s*(['"`])([^'"`]+)\1/);
   if (!match) return undefined;
   const routePath = match[2];
   return nativeDeclaration(input, lineNumber, 'RouteRecord', 'route', `${context.name}.${routePath}`, {
@@ -224,7 +224,19 @@ function jsContainerWrapperLooksSemantic(callee, name, source) {
 
 function jsContainerDelta(source) {
   let delta = 0;
+  let quote;
+  let escaped = false;
   for (const char of String(source ?? '')) {
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
     if (char === '{' || char === '[') delta += 1;
     if (char === '}' || char === ']') delta -= 1;
   }

package/dist/native-region-scanner-js-nested.js

@@ -0,0 +1,147 @@
+import { nativeDeclaration } from './native-region-scanner-core.js';
+import { jsContainerDelta, jsRegionKindForDeclarationName } from './native-region-scanner-js-helpers.js';
+
+function jsCurrentObjectContext(stack) {
+  return stack[stack.length - 1];
+}
+
+function jsContextAllowsPropertyScan(context) {
+  return context?.initializerKind === 'object';
+}
+
+function jsNestedObjectContextFromDeclaration(declaration, lineNumber, source) {
+  const initializerKind = declaration?.fields?.initializerKind ?? declaration?.metadata?.initializerKind;
+  if (initializerKind !== 'object' && initializerKind !== 'array') return undefined;
+  const depth = jsContainerDelta(source);
+  if (depth <= 0) return undefined;
+  return {
+    name: declaration.name,
+    regionKind: declaration.regionKind ?? declaration.metadata?.regionKind,
+    initializerKind,
+    depth,
+    startLine: lineNumber
+  };
+}
+
+function jsInlineNestedObjectDeclarations(input, lineNumber, source, parentDeclaration, depth = 0) {
+  const parentInitializerKind = parentDeclaration?.fields?.initializerKind ?? parentDeclaration?.metadata?.initializerKind;
+  if (depth > 4 || parentInitializerKind !== 'object') return [];
+  const body = inlineObjectBody(source);
+  if (body === undefined) return [];
+  const declarations = [];
+  for (const entry of splitTopLevelEntries(body)) {
+    const parsed = parseObjectEntry(entry);
+    if (!parsed) continue;
+    const initializerKind = nestedInitializerKind(parsed.value);
+    const name = `${parentDeclaration.name}.${parsed.key}`;
+    const regionKind = nestedPropertyRegionKind(parentDeclaration, parsed.key, parsed.value);
+    const declaration = nativeDeclaration(input, lineNumber, initializerKind === 'function' ? 'NestedObjectFunctionProperty' : 'NestedObjectProperty', initializerKind === 'function' ? 'function' : 'property', name, {
+      owner: parentDeclaration.name,
+      propertyName: parsed.key,
+      initializerKind
+    }, initializerKind === 'object' || initializerKind === 'array' || initializerKind === 'function', {
+      regionKind,
+      metadata: { owner: parentDeclaration.name, propertyName: parsed.key, initializerKind }
+    });
+    declarations.push(declaration);
+    declarations.push(...jsInlineNestedObjectDeclarations(input, lineNumber, parsed.value, declaration, depth + 1));
+  }
+  return declarations;
+}
+
+function updateJsObjectContextStack(stack, lineNumber, source) {
+  const delta = jsContainerDelta(source);
+  for (const context of stack) {
+    if (context.startLine !== lineNumber) context.depth += delta;
+  }
+  while (stack.length && stack[stack.length - 1].depth <= 0) stack.pop();
+}
+
+function inlineObjectBody(source) {
+  const text = String(source ?? '');
+  const open = text.indexOf('{');
+  if (open < 0) return undefined;
+  let quote;
+  let escaped = false;
+  let depth = 0;
+  for (let index = open; index < text.length; index += 1) {
+    const char = text[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') {
+      quote = char;
+      continue;
+    }
+    if (char === '{') depth += 1;
+    else if (char === '}') {
+      depth -= 1;
+      if (depth === 0) return text.slice(open + 1, index);
+    }
+  }
+  return undefined;
+}
+
+function splitTopLevelEntries(body) {
+  const entries = [];
+  let quote;
+  let escaped = false;
+  let depth = 0;
+  let start = 0;
+  const text = String(body ?? '');
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === quote) quote = undefined;
+      continue;
+    }
+    if (char === '\'' || char === '"' || char === '`') quote = char;
+    else if (char === '{' || char === '[' || char === '(') depth += 1;
+    else if (char === '}' || char === ']' || char === ')') depth -= 1;
+    else if (char === ',' && depth === 0) {
+      entries.push(text.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  entries.push(text.slice(start).trim());
+  return entries.filter(Boolean);
+}
+
+function parseObjectEntry(entry) {
+  if (!entry || entry.startsWith('...') || entry.startsWith('[')) return undefined;
+  const match = entry.match(/^(?:(['"])([^'"]+)\1|([A-Za-z_$][\w$-]*))\s*:\s*(.+)$/s);
+  if (!match) return undefined;
+  return { key: match[2] ?? match[3], value: match[4].trim() };
+}
+
+function nestedInitializerKind(value) {
+  const text = String(value ?? '').trim();
+  if (text.startsWith('{')) return 'object';
+  if (text.startsWith('[')) return 'array';
+  if (/^(?:async\s*)?(?:function\b|\([^)]*\)\s*=>|[A-Za-z_$][\w$]*\s*=>)/.test(text)) return 'function';
+  if (/^['"`]/.test(text)) return 'string';
+  if (/^(?:true|false)\b/.test(text)) return 'boolean';
+  if (/^[0-9]/.test(text)) return 'number';
+  return 'expression';
+}
+
+function nestedPropertyRegionKind(parentDeclaration, propertyName, value) {
+  return jsRegionKindForDeclarationName(propertyName, value)
+    ?? parentDeclaration.regionKind
+    ?? parentDeclaration.metadata?.ownershipRegionKind
+    ?? parentDeclaration.metadata?.regionKind
+    ?? 'property';
+}
+
+export {
+  jsContextAllowsPropertyScan,
+  jsCurrentObjectContext,
+  jsInlineNestedObjectDeclarations,
+  jsNestedObjectContextFromDeclaration,
+  updateJsObjectContextStack
+};

package/dist/native-region-scanner-js.js

@@ -20,6 +20,13 @@ import {
   jsVariableHasBody,
   jsVariableSymbolKind
 } from './native-region-scanner-js-helpers.js';
+import {
+  jsContextAllowsPropertyScan,
+  jsCurrentObjectContext,
+  jsInlineNestedObjectDeclarations,
+  jsNestedObjectContextFromDeclaration,
+  updateJsObjectContextStack
+} from './native-region-scanner-js-nested.js';
 
 function scanJavaScriptLike(input) {
   const declarations = [];
@@ -32,7 +39,7 @@ function scanJavaScriptLike(input) {
   };
   let currentClass;
   let classDepth = 0;
-  let currentObject;
+  const objectStack = [];
   let currentType;
   const lexicalState = { inBlockComment: false, inTemplateString: false };
   for (const { line, number } of lines) {
@@ -44,13 +51,19 @@ function scanJavaScriptLike(input) {
     if (currentType && number !== currentType.startLine) {
       pushDeclaration(jsTypeMemberDeclaration(input, number, declarationLine, currentType));
     }
+    const currentObject = jsCurrentObjectContext(objectStack);
     if (currentObject) {
       const routeRecord = jsRouteRecordDeclaration(input, number, trimmed, currentObject);
       if (routeRecord) {
         pushDeclaration(routeRecord);
-      } else {
+      } else if (jsContextAllowsPropertyScan(currentObject)) {
         const property = jsObjectPropertyDeclaration(input, number, trimmed, currentObject);
-        if (property) pushDeclaration(property);
+        if (property) {
+          pushDeclaration(property);
+          pushDeclarations(jsInlineNestedObjectDeclarations(input, number, trimmed, property));
+          const nestedContext = jsNestedObjectContextFromDeclaration(property, number, trimmed);
+          if (nestedContext) objectStack.push(nestedContext);
+        }
       }
     }
     const importDeclarations = jsImportDeclarations(input, number, trimmed);
@@ -93,10 +106,13 @@ function scanJavaScriptLike(input) {
         regionKind,
         metadata: { initializerKind }
       }));
-      currentObject = jsObjectRegionContext(match[1], declarationLine, number, regionKind);
+      pushDeclarations(jsInlineNestedObjectDeclarations(input, number, declarationLine, declarations[declarations.length - 1]));
+      const objectContext = jsObjectRegionContext(match[1], declarationLine, number, regionKind);
+      if (objectContext) objectStack.push(objectContext);
     } else if ((match = jsExportedContainerDeclaration(input, number, trimmed))) {
       pushDeclaration(match.declaration);
-      currentObject = match.context;
+      pushDeclarations(jsInlineNestedObjectDeclarations(input, number, trimmed, match.declaration));
+      if (match.context) objectStack.push(match.context);
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?function\*?\s*\(([^)]*)\)/))) {
       pushDeclaration(nativeDeclaration(input, number, 'CommonJsFunctionExport', 'function', match[1], { parameters: splitParameters(match[2]) }, true));
     } else if ((match = trimmed.match(/^(?:module\.)?exports\.([A-Za-z_$][\w$]*)\s*=/))) {
@@ -126,10 +142,7 @@ function scanJavaScriptLike(input) {
       if (number !== currentType.startLine) currentType.depth += jsStructureDelta(trimmed).value;
       if (currentType.depth <= 0) currentType = undefined;
     }
-    if (currentObject) {
-      if (number !== currentObject.startLine) currentObject.depth += jsContainerDelta(trimmed);
-      if (currentObject.depth <= 0) currentObject = undefined;
-    }
+    updateJsObjectContextStack(objectStack, number, trimmed);
   }
   return declarations;
 }

package/package.json

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