@pygmalionjs/pygmalion 0.9.0 → 0.10.0

package/dist-lib/{runtime-Dxb-IaLN.js → runtime-BOfDlGPR.js}

@@ -18872,6 +18872,25 @@ class XS {
     this.disposed || (this.cancelPreparation(), this.disposed = !0, this.listeners.clear(), this.designContexts.clear());
   }
 }
+function dI({ resolve: t, maxEntries: e = 8 }) {
+  if (typeof t != "function" || !Number.isSafeInteger(e) || e < 0)
+    throw new Error("A target resolver requires a callback and a non-negative integer cache limit.");
+  const n = /* @__PURE__ */ new Map();
+  return (r) => {
+    if (typeof (r == null ? void 0 : r.screenId) != "string" || !r.screenId.trim() || typeof r.sourceRevision != "string" || !r.sourceRevision.trim())
+      throw new Error("A workspace target requires a screen and source revision.");
+    const i = Object.freeze({ screenId: r.screenId, sourceRevision: r.sourceRevision }), s = JSON.stringify([i.screenId, i.sourceRevision]), o = n.get(s);
+    if (o !== void 0)
+      return n.delete(s), n.set(s, o), o;
+    const a = t(i);
+    if (a !== void 0 && e > 0)
+      for (n.set(s, a); n.size > e; ) {
+        const u = n.keys().next().value;
+        u !== void 0 && n.delete(u);
+      }
+    return a;
+  };
+}
 function ZS(t, e) {
   var r, i;
   if (!((r = e.screenId) != null && r.trim()) || !((i = e.sourceRevision) != null && i.trim())) throw new Error("A workspace target requires a screen and source revision.");
@@ -19379,7 +19398,7 @@ function c_() {
     createFrameLodController: p
   };
 }
-const dI = 3, u_ = 5;
+const fI = 3, u_ = 5;
 function l_() {
   const t = /* @__PURE__ */ new Set();
   let e = [], n = [], r = [], i = 0, s = 0;
@@ -19532,7 +19551,7 @@ const h_ = /* @__PURE__ */ new Set([
   total: 0,
   jobCount: 0
 });
-function fI(t) {
+function hI(t) {
   return `${t.replace(/\/$/, "")}${Nv}`;
 }
 function p_(t) {
@@ -19592,7 +19611,7 @@ function g_(t, e, n) {
     state: s
   };
 }
-function hI(t) {
+function pI(t) {
   const e = t.transport, n = e.endpoints.previewCaptureProgress ?? null, [r, i] = Ei(
     _i
   ), s = t.schedulers.captureProgress, o = ku(
@@ -20684,7 +20703,7 @@ function L_(t) {
           stamped: u ? i.isStampedFrozenPreview(u.root) : null
         },
         lodState: a.__debugFrameLodState(),
-        readFramesNow: (await import("./CameraLayer-BdOko8XE.js")).__debugReadEditorFrames(t).find((h) => h.id === n)
+        readFramesNow: (await import("./CameraLayer-BUOlJcUa.js")).__debugReadEditorFrames(t).find((h) => h.id === n)
       };
     },
     /** Flow-session delivery states for headless diagnosis of the captureless supply. */
@@ -20735,7 +20754,7 @@ function L_(t) {
     }
   };
 }
-function pI(t = {}) {
+function mI(t = {}) {
   const e = new F_(t.host), n = Pa(), r = gd(), i = Sa(), s = new Ki({ host: e, surfaces: r, declarations: n, shadowMounts: i }), o = Ia(), a = Fw({ metrics: o, declarations: n });
   return j_({
     store: s,
@@ -20908,7 +20927,7 @@ export {
   F0 as ay,
   k0 as az,
   Mr as b,
-  m0 as b$,
+  ih as b$,
   zu as b0,
   Yf as b1,
   Wf as b2,
@@ -20919,39 +20938,39 @@ export {
   no as b7,
   Pc as b8,
   No as b9,
-  G0 as bA,
-  ww as bB,
-  _w as bC,
-  X0 as bD,
-  Q_ as bE,
-  e0 as bF,
-  g0 as bG,
-  yu as bH,
-  Uu as bI,
-  co as bJ,
-  ao as bK,
-  Ep as bL,
-  Va as bM,
-  fI as bN,
-  W_ as bO,
-  E0 as bP,
-  A0 as bQ,
-  Jf as bR,
-  q_ as bS,
-  Sw as bT,
-  eb as bU,
-  $v as bV,
-  j0 as bW,
-  J0 as bX,
-  fw as bY,
-  hI as bZ,
-  ih as b_,
+  dI as bA,
+  G0 as bB,
+  ww as bC,
+  _w as bD,
+  X0 as bE,
+  Q_ as bF,
+  e0 as bG,
+  g0 as bH,
+  yu as bI,
+  Uu as bJ,
+  co as bK,
+  ao as bL,
+  Ep as bM,
+  Va as bN,
+  hI as bO,
+  W_ as bP,
+  E0 as bQ,
+  A0 as bR,
+  Jf as bS,
+  q_ as bT,
+  Sw as bU,
+  eb as bV,
+  $v as bW,
+  j0 as bX,
+  J0 as bY,
+  fw as bZ,
+  pI as b_,
   d_ as ba,
   dt as bb,
   pd as bc,
   Dd as bd,
-  pI as be,
-  dI as bf,
+  mI as be,
+  fI as bf,
   O0 as bg,
   N0 as bh,
   d0 as bi,
@@ -20973,23 +20992,24 @@ export {
   Fd as by,
   Gy as bz,
   Zn as c,
-  Lp as c0,
-  Qy as c1,
-  os as c2,
-  Xb as c3,
-  D0 as c4,
-  z0 as c5,
-  f0 as c6,
-  T0 as c7,
-  L0 as c8,
-  H0 as c9,
-  Y0 as ca,
-  Ki as cb,
-  NS as cc,
-  je as cd,
-  o0 as ce,
-  s0 as cf,
-  u0 as cg,
+  m0 as c0,
+  Lp as c1,
+  Qy as c2,
+  os as c3,
+  Xb as c4,
+  D0 as c5,
+  z0 as c6,
+  f0 as c7,
+  T0 as c8,
+  L0 as c9,
+  H0 as ca,
+  Y0 as cb,
+  Ki as cc,
+  NS as cd,
+  je as ce,
+  o0 as cf,
+  s0 as cg,
+  u0 as ch,
   Xf as d,
   K_ as e,
   Hu as f,

package/dist-lib/testing.js

@@ -1,5 +1,5 @@
-import { bV as l, T as u } from "./runtime-Dxb-IaLN.js";
-import { bi as w, cb as y, cc as E, cd as P, be as T, as as V } from "./runtime-Dxb-IaLN.js";
+import { bW as l, T as u } from "./runtime-BOfDlGPR.js";
+import { bi as y, cc as b, cd as E, ce as P, be as T, as as $ } from "./runtime-BOfDlGPR.js";
 const v = {
   mirror: ["status", "refresh", "refs"],
   session: ["open", "check", "previewVisual", "applyVisual", "revertVisual"],
@@ -9,11 +9,11 @@ const v = {
   storyboard: ["environment", "sourceUsage", "componentBranches"]
 };
 function g(m = {}, t = {}) {
-  const n = [], d = t.origin ?? "", r = (e) => {
+  const n = [], d = t.origin ?? "", e = (r) => {
     var a;
     const i = {};
-    for (const o of v[e]) {
-      const s = `${e}.${String(o)}`, c = (a = m[e]) == null ? void 0 : a[o];
+    for (const o of v[r]) {
+      const s = `${r}.${String(o)}`, c = (a = m[r]) == null ? void 0 : a[o];
       i[String(o)] = (...p) => (n.push({ operation: s, request: p[0] }), c ? Promise.resolve(c(...p)) : Promise.reject(
         new u({
           operation: s,
@@ -27,21 +27,21 @@ function g(m = {}, t = {}) {
   return {
     calls: n,
     endpoints: l(t.endpoints),
-    resolveUrl: (e) => `${d}${e}`,
-    mirror: r("mirror"),
-    session: r("session"),
-    inspect: r("inspect"),
-    qa: r("qa"),
-    preview: r("preview"),
-    storyboard: r("storyboard")
+    resolveUrl: (r) => `${d}${r}`,
+    mirror: e("mirror"),
+    session: e("session"),
+    inspect: e("inspect"),
+    qa: e("qa"),
+    preview: e("preview"),
+    storyboard: e("storyboard")
   };
 }
 export {
-  w as EditorRuntimeProvider,
-  y as EditorStore,
+  y as EditorRuntimeProvider,
+  b as EditorStore,
   E as FrozenRoutePreviewView,
   P as NodeModel,
   T as createEditorRuntime,
   g as createMemoryTransport,
-  V as serializeNode
+  $ as serializeNode
 };

package/dist-lib/types/binding/duplicateMetadata.d.ts

@@ -0,0 +1,8 @@
+import type { DataCatalog } from './contracts.js';
+import type { DocumentDuplicateMetadataRemapper } from '../document/contracts.js';
+export interface DataBindingMetadataDuplicatorOptions {
+    /** Host-declared metadata containing no node references that require remapping. */
+    preservedMetadataKeys?: readonly string[];
+}
+/** Copies binding relationships while retaining only explicitly declared, reference-free metadata. */
+export declare function createDataBindingMetadataDuplicator(catalog: DataCatalog, options?: DataBindingMetadataDuplicatorOptions): DocumentDuplicateMetadataRemapper;

package/dist-lib/types/binding/index.d.ts

@@ -4,3 +4,4 @@ export * from './validate.js';
 export * from './preview.js';
 export * from './source.js';
 export * from './documentCommands.js';
+export * from './duplicateMetadata.js';

package/dist-lib/types/lib.d.ts

@@ -10,6 +10,8 @@ export type { StylesPanelProps } from './workspace/edit/StylesPanel.js';
 export { TokenLibraryProvider, useTokenLibraryController, useHasTokenLibraryProvider } from './workspace/tokens/TokenLibraryContext.js';
 export { createTokenLibraryEngine, reopenTokenLibrary, validateTokenLibraryDocument, resolveTokenLibraryValue, tokenValueEditability, TokenLibraryValidationError } from './token-library/engine.js';
 export type * from './token-library/contracts.js';
+export { createTokenValueResolver } from './token-library/valueResolver.js';
+export type { TokenValueReferenceRange, TokenValueResolverOptions, ResolvedTokenText } from './token-library/valueResolver.js';
 export type * from './workspace/tokens/contracts.js';
 export { WorkspaceTokenLibraryController } from './workspace/tokens/controller.js';
 export type { WorkspaceTokenLibraryState } from './workspace/tokens/controller.js';
@@ -27,8 +29,8 @@ export type { InspectSourceRuntime, SourceWritePolicy, SourceWriteErrorCode } fr
 export { WorkspaceController } from './workspace/controller.js';
 export { createLegacyModeAdapter } from './workspace/legacyModeAdapter.js';
 export type * from './workspace/contracts.js';
-export { resolveWorkspaceTarget } from './workspace/configuration.js';
-export type { WorkspaceConfiguration, WorkspaceTargetConfiguration } from './workspace/configuration.js';
+export { createWorkspaceTargetResolver, resolveWorkspaceTarget } from './workspace/configuration.js';
+export type { WorkspaceConfiguration, WorkspaceTargetConfiguration, WorkspaceTargetResolverOptions } from './workspace/configuration.js';
 export { compileWorkspaceVisualSource, workspaceSourceFingerprint } from './workspace/source/compiler.js';
 export { compileWorkspaceDocumentSource, jsxStructureWrapperClassName } from './workspace/source/structure.js';
 export { compileWorkspaceResponsiveSource, resolveResponsiveLayout, setResponsiveLayoutOverride } from './workspace/source/responsive.js';

package/dist-lib/types/token-library/valueResolver.d.ts

@@ -0,0 +1,19 @@
+import type { ResolvedTokenReference, TokenLibraryDiagnostic, TokenLibraryDocument, TokenValueResolution } from './contracts.js';
+export interface TokenValueReferenceRange {
+    start: number;
+    end: number;
+    /** Must be one of the resolution's declared references. */
+    reference: ResolvedTokenReference;
+}
+export interface TokenValueResolverOptions {
+    /** Extend a reference's replacement range to host-owned surrounding syntax, such as a function call. */
+    referenceRanges?(resolution: TokenValueResolution): readonly TokenValueReferenceRange[];
+}
+export interface ResolvedTokenText {
+    status: 'resolved' | 'blocked';
+    text?: string;
+    resolution?: TokenValueResolution;
+    diagnostics: readonly TokenLibraryDiagnostic[];
+}
+/** Resolves a captured library's declared reference graph and caches text by token and requested mode. */
+export declare function createTokenValueResolver(input: TokenLibraryDocument, options?: TokenValueResolverOptions): (tokenId: string, modeId: string) => ResolvedTokenText;

package/dist-lib/types/workspace/configuration.d.ts

@@ -33,6 +33,14 @@ export interface WorkspaceConfiguration extends WorkspaceTargetConfiguration {
     /** Undefined explicitly marks an unsupported screen or source revision. */
     resolveTarget?(target: WorkspaceTarget): WorkspaceTargetConfiguration | undefined;
 }
+export interface WorkspaceTargetResolverOptions {
+    /** The host decides whether this screen and revision have usable capabilities. */
+    resolve(target: Readonly<WorkspaceTarget>): WorkspaceTargetConfiguration | undefined;
+    /** Maximum retained target configurations; zero disables caching. Default: 8. */
+    maxEntries?: number;
+}
+/** Retain capability identities per screen and revision; unsupported targets remain retryable. */
+export declare function createWorkspaceTargetResolver({ resolve, maxEntries }: WorkspaceTargetResolverOptions): (target: WorkspaceTarget) => WorkspaceTargetConfiguration | undefined;
 /** An explicit target resolver never inherits capabilities from the root configuration. */
 export declare function resolveWorkspaceTarget(configuration: WorkspaceConfiguration, target: WorkspaceTarget): WorkspaceTargetConfiguration | undefined;
 /** Compares captured capability identities without invoking any host callbacks. */

package/host-runtime.d.ts

@@ -0,0 +1,73 @@
+import type { SpawnOptions } from 'node:child_process';
+import type { PygmalionRevisionCatalog } from './dist-lib/types/editor/revisionCatalog.js';
+
+export interface WorkspaceDraftProcessOptions extends Omit<SpawnOptions, 'signal' | 'detached' | 'stdio' | 'timeout' | 'killSignal'> {
+  signal?: AbortSignal;
+  /** Milliseconds before cancellation. Zero disables the deadline. Default: 240,000. */
+  timeout?: number;
+  /** Milliseconds between SIGTERM and SIGKILL. Default: 1,000. */
+  terminationGraceMs?: number;
+  /** Maximum bytes per output stream. Default: 8 MiB. */
+  maxBuffer?: number;
+}
+
+/** macOS/Linux: waits for process-group cleanup on success, failure, cancellation, and timeout. */
+export declare function executeWorkspaceDraftProcess(
+  command: string, args: readonly string[], options?: WorkspaceDraftProcessOptions,
+): Promise<{ stdout: string; stderr: string }>;
+
+export interface RevisionCatalogResolver {
+  /** Only complete SHA-1 or SHA-256 commits are accepted; returned catalogs are frozen copies. */
+  resolve(sourceRevision: string, signal?: AbortSignal): Promise<PygmalionRevisionCatalog>;
+  currentRevision(signal?: AbortSignal): Promise<string>;
+  /** Least recently used first; expired and current-build entries are omitted. */
+  retained(): string[];
+  /** Cancels owned generation, discards cached results, and rejects subsequent requests. */
+  dispose(): void;
+}
+
+export interface RevisionCatalogResolverOptions {
+  projectRoot?: string;
+  /** Repository-relative application directory. Default: the repository root. */
+  appDirectory?: string;
+  currentCatalog(signal?: AbortSignal): unknown | Promise<unknown>;
+  generate(context: { archiveRoot: string; sourceRevision: string; signal: AbortSignal }): unknown | Promise<unknown>;
+  /** Defaults to commits reachable from HEAD or repository branches, remotes, and tags. */
+  reachable?(sourceRevision: string, signal: AbortSignal): boolean | Promise<boolean>;
+  /** Custom extraction must await its callback and stop workers before removing source files. */
+  archive?<T>(sourceRevision: string, signal: AbortSignal,
+    operation: (context: Readonly<{ appRoot: string; sourceRevision: string; signal: AbortSignal }>) => Promise<T>): Promise<T>;
+  /** Defaults to 4 archived catalogs; zero disables retention. */
+  maxEntries?: number;
+  /** Absolute lifetime since generation, in milliseconds. Default: 30 minutes. */
+  maxAgeMs?: number;
+}
+
+/** Shares requests for each revision and serializes archive/build work across revisions. */
+export declare function createRevisionCatalogResolver(options: RevisionCatalogResolverOptions): RevisionCatalogResolver;
+
+/** Returns dependency search paths from the first byte-identical lockfile, or [] for an archive-local install. */
+export declare function resolveSourceArchiveDependencies(options: {
+  archiveRoot: string; dependencyRoots: readonly string[]; lockfile?: string;
+}): Promise<string[]>;
+
+/** Rejects host worktrees, Git metadata, and missing or linked required directories. */
+export declare function assertIsolatedSourceRoot(options: {
+  archiveRoot: string; hostRoot: string; requiredDirectories?: readonly string[];
+}): Promise<string>;
+
+/** Converts SIGTERM/SIGINT into cancellation and exit status; dispose removes its process listeners. */
+export declare function createWorkspaceDraftLifecycle(): Readonly<{
+  signal: AbortSignal;
+  dispose(): void;
+}>;
+
+/** Requires canonical source/output directories belonging to one SDK draft-preview temporary root. */
+export declare function assertWorkspaceDraftDirectories(options: {
+  appRoot: string; outputDirectory: string; appDirectory?: string;
+}): Promise<Readonly<{ appRoot: string; outputDirectory: string; temporaryRoot: string }>>;
+
+/** Imports the installed package's explicit exports['.'].import entry; no parent-install fallback. */
+export declare function importIsolatedPackage<T = Record<string, unknown>>(options: {
+  appRoot: string; name: string;
+}): Promise<T>;

package/jsx-source-reconciler.d.ts

@@ -0,0 +1,35 @@
+import type { WorkspaceTarget } from './dist-lib/types/workspace/contracts.js';
+import type { WorkspaceSourceBaseline, WorkspaceSourceReconcileInput, WorkspaceSourceReconcileResult } from './dist-lib/types/workspace/source/flowContracts.js';
+import type { compileWorkspaceDocumentSource } from './dist-lib/types/workspace/source/structure.js';
+import type { JsxStructureAnchor, JsxStructureIdentity, JsxStructureSourceNode, JsxStructureWrapperEvidence } from './source-structure.js';
+
+export type ReconcileSourceInputs = Readonly<Record<string, string | null>>;
+export interface ReconcileSourceProjection { anchors: JsxStructureAnchor[]; nodes: JsxStructureSourceNode[] }
+export interface JsxSourceReconcilerOptions {
+  file: string;
+  identityFile: string;
+  rootId: string;
+  definitionId: string;
+  screenId: string;
+  documentId: string;
+  opaqueNodeIds: readonly string[];
+  /** The owner validates original expressions and allowed source structure. */
+  projectSource(input: { source: string; identity: JsxStructureIdentity | null; sourceInputs: ReconcileSourceInputs }): ReconcileSourceProjection;
+  resolveWrapper?(inputs: ReconcileSourceInputs): JsxStructureWrapperEvidence | undefined;
+  /** Pass the SDK's document compiler; injecting it avoids loading the browser bundle in Node. */
+  compileDocumentSource: typeof compileWorkspaceDocumentSource;
+  /** Explicit policy for a unique byte-identical island; changed or duplicate islands remain conflicts. Default: false. */
+  allowUnchangedIslandRelocation?: boolean;
+}
+export interface JsxReconcileInputs {
+  baselineInputs: ReconcileSourceInputs;
+  externalInputs: ReconcileSourceInputs;
+  baselineIdentity?: JsxStructureIdentity;
+}
+export interface JsxSourceReconciler {
+  projectInputs(input: JsxReconcileInputs): { identity: JsxStructureIdentity; projectedStructure: ReconcileSourceProjection };
+  reconcile(input: WorkspaceSourceReconcileInput & JsxReconcileInputs & {
+    loadBaseline(input: { target: WorkspaceTarget; sourceInputs: ReconcileSourceInputs; projectedStructure: ReconcileSourceProjection }, signal?: AbortSignal): Promise<WorkspaceSourceBaseline>;
+  }, signal?: AbortSignal): Promise<WorkspaceSourceReconcileResult>;
+}
+export declare function createJsxSourceReconciler(options: JsxSourceReconcilerOptions): JsxSourceReconciler;

package/node/host-runtime.mjs

@@ -0,0 +1,4 @@
+export { executeWorkspaceDraftProcess } from './workspace-draft-process.mjs';
+export { createRevisionCatalogResolver } from './revision-catalog-resolver.mjs';
+export { assertIsolatedSourceRoot, resolveSourceArchiveDependencies } from './source-archive-runtime.mjs';
+export { createWorkspaceDraftLifecycle, assertWorkspaceDraftDirectories, importIsolatedPackage } from './workspace-draft-runtime.mjs';

package/node/jsx-source-reconciler.mjs

@@ -0,0 +1,155 @@
+import { createHash } from 'node:crypto';
+import { workspaceSourceFingerprint as fingerprint } from './workspace-source-identity.mjs';
+import { createJsxStructureIdentity, reconcileJsxStructurePlan, reimportJsxStructureSource } from './source-structure.mjs';
+
+const hash = value => createHash('sha256').update(value).digest('hex');
+const same = (left, right) => fingerprint(left) === fingerprint(right);
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+function freeze(value) {
+  if (value && typeof value === 'object' && !Object.isFrozen(value)) { Object.values(value).forEach(freeze); Object.freeze(value); }
+  return value;
+}
+const capture = value => freeze(JSON.parse(fingerprint(value)));
+function fail(code, message, file) {
+  throw Object.assign(new Error(message), { diagnostics: [{ code: `source-reconcile-${code}`, message, ...(file ? { file } : {}) }] });
+}
+const sourceLayout = layout => layout ? { direction: layout.direction, gap: layout.gap, padding: layout.padding, ...(layout.align === undefined ? {} : { align: layout.align }) } : null;
+
+/** Reconciles one explicitly declared, unchanged source island while delegating product ownership to its projector. */
+export function createJsxSourceReconciler({
+  file, identityFile, rootId, definitionId, screenId, documentId, opaqueNodeIds,
+  projectSource, resolveWrapper = () => undefined, compileDocumentSource,
+  allowUnchangedIslandRelocation = false,
+}) {
+  if ([file, identityFile, rootId, definitionId, screenId, documentId].some(value => typeof value !== 'string' || !value)
+    || file === identityFile || !Array.isArray(opaqueNodeIds) || new Set(opaqueNodeIds).size !== opaqueNodeIds.length
+    || opaqueNodeIds.some(value => typeof value !== 'string' || !value)
+    || ![projectSource, resolveWrapper, compileDocumentSource].every(value => typeof value === 'function')) {
+    throw new TypeError('A source reconciler requires explicit files, node identities, and projection/compiler callbacks.');
+  }
+  opaqueNodeIds = [...opaqueNodeIds];
+  function capturedInputs(value) {
+    if (!record(value) || Object.keys(value).length > 500 || !Object.hasOwn(value, identityFile)
+      || typeof value[file] !== 'string' || !value[file]) fail('inputs-invalid', 'Complete source and identity inputs are required.');
+    let size = 0;
+    for (const [inputFile, content] of Object.entries(value)) {
+      if (content === null && inputFile === identityFile) continue;
+      if (typeof content !== 'string' || Buffer.from(content).toString('utf8') !== content) fail('inputs-invalid', 'Source inputs must be UTF-8 strings.', inputFile);
+      size += Buffer.byteLength(content);
+    }
+    if (size > 32 * 1024 * 1024) fail('inputs-invalid', 'Source inputs exceed the reconciliation size limit.');
+  }
+  function sourceIdentity(inputs, baselineIdentity) {
+    const source = inputs[file];
+    const supplied = baselineIdentity ?? (inputs[identityFile] === null ? null : JSON.parse(inputs[identityFile]));
+    const wrapper = resolveWrapper(inputs);
+    const projectedStructure = capture(projectSource({ source, identity: supplied, sourceInputs: inputs }));
+    const identity = supplied ?? createJsxStructureIdentity({
+      file, source, rootId, anchors: projectedStructure.anchors, opaqueNodeIds, ...(wrapper ? { wrapper } : {}),
+    });
+    return { identity, projectedStructure, wrapper };
+  }
+  function projectInputs(input) {
+    const { baselineInputs, externalInputs, baselineIdentity } = capture({
+      baselineInputs: input.baselineInputs, externalInputs: input.externalInputs,
+      ...(input.baselineIdentity === undefined ? {} : { baselineIdentity: input.baselineIdentity }),
+    });
+    capturedInputs(baselineInputs); capturedInputs(externalInputs);
+    if (!same(Object.keys(baselineInputs).sort(), Object.keys(externalInputs).sort())) fail('input-set-conflict', 'The complete source input sets differ.');
+    for (const inputFile of Object.keys(baselineInputs)) {
+      if (![file, identityFile].includes(inputFile) && baselineInputs[inputFile] !== externalInputs[inputFile]) {
+        fail('dependency-conflict', 'A source dependency changed and requires separate review.', inputFile);
+      }
+    }
+    const original = sourceIdentity(baselineInputs, baselineIdentity);
+    const oldRoot = original.projectedStructure.anchors.find(anchor => anchor.nodeId === rootId);
+    if (!oldRoot) fail('island-conflict', 'The declared source island is missing.', file);
+    const source = externalInputs[file];
+    const start = source.indexOf(oldRoot.expected);
+    if (start < 0 || source.indexOf(oldRoot.expected, start + oldRoot.expected.length) !== -1) {
+      fail('island-conflict', 'The source island changed or no longer has a unique unchanged match.', file);
+    }
+    if (source !== baselineInputs[file] && !allowUnchangedIslandRelocation) {
+      fail('relocation-disabled', 'The source owner has not allowed unchanged island relocation.', file);
+    }
+    const offset = start - oldRoot.start;
+    const anchors = original.projectedStructure.anchors.map(anchor => ({ ...anchor, start: anchor.start + offset, end: anchor.end + offset }));
+    const wrapper = resolveWrapper(externalInputs);
+    const identity = createJsxStructureIdentity({ file, source, rootId, anchors, opaqueNodeIds: original.identity.opaqueNodeIds, ...(wrapper ? { wrapper } : {}) });
+    if (externalInputs[identityFile] !== baselineInputs[identityFile]
+      && (externalInputs[identityFile] === null || !same(JSON.parse(externalInputs[identityFile]), identity))) {
+      fail('ledger-conflict', 'The external identity ledger differs from the proven current source correspondence.', identityFile);
+    }
+    return capture({ identity, projectedStructure: projectSource({ source, identity, sourceInputs: externalInputs }) });
+  }
+  function verifyProofs(mapping, inputs) {
+    if (!Array.isArray(mapping?.files) || !mapping.files.length) fail('proofs-invalid', 'Baseline source proofs are required.');
+    const seen = new Set();
+    for (const proof of mapping.files) {
+      if (!proof || typeof proof.file !== 'string' || seen.has(proof.file) || !Object.hasOwn(inputs, proof.file)
+        || proof.sha256 !== (inputs[proof.file] === null ? null : hash(inputs[proof.file]))) {
+        fail('proofs-invalid', 'Baseline proofs do not match the source bytes.', proof?.file);
+      }
+      seen.add(proof.file);
+    }
+    if (!seen.has(file) || !seen.has(identityFile)) fail('proofs-invalid', 'Source and identity proofs are both required.');
+  }
+  function verifyProjection(document, projection) {
+    for (const node of projection.nodes) {
+      const current = document.nodes[node.nodeId];
+      const parentId = node.nodeId === rootId ? definitionId : node.parentId;
+      if (!current || current.parentId !== parentId || !same(current.children, node.children) || !same(sourceLayout(current.layout), sourceLayout(node.layout))) {
+        fail('document-conflict', 'The reconciled source hierarchy differs from the edited document.');
+      }
+    }
+  }
+  async function reconcile(input, signal) {
+    try {
+      signal?.throwIfAborted();
+      const loadBaseline = input?.loadBaseline;
+      if (typeof loadBaseline !== 'function') fail('loader-invalid', 'A source baseline loader is required.');
+      const { target, baseline, document, baselineInputs, externalInputs, baselineIdentity } = capture({
+        target: input.target, baseline: input.baseline, document: input.document,
+        baselineInputs: input.baselineInputs, externalInputs: input.externalInputs,
+        ...(input.baselineIdentity === undefined ? {} : { baselineIdentity: input.baselineIdentity }),
+      });
+      if (target?.screenId !== screenId || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(target.sourceRevision ?? '')
+        || baseline?.document?.id !== documentId || document?.id !== documentId
+        || baseline.document.sourceRevision !== target.sourceRevision || document.sourceRevision !== target.sourceRevision
+        || !same(baseline.mapping?.target, target)) fail('target-conflict', 'Screen, document, and exact source revision must match.');
+      capturedInputs(baselineInputs); capturedInputs(externalInputs);
+      verifyProofs(baseline.mapping, baselineInputs);
+      const original = sourceIdentity(baselineInputs, baselineIdentity);
+      const latest = projectInputs({ baselineInputs, externalInputs, ...(baselineIdentity === undefined ? {} : { baselineIdentity }) });
+      const verifiedBaseline = capture(await loadBaseline(freeze({ target, sourceInputs: baselineInputs, projectedStructure: original.projectedStructure }), signal));
+      signal?.throwIfAborted();
+      if (!same(verifiedBaseline, baseline)) fail('baseline-conflict', 'The supplied baseline differs from the document projected from its source.');
+      const planned = compileDocumentSource({ target, before: baseline.document, after: document, mapping: baseline.mapping });
+      if (planned.status === 'blocked') return freeze({ status: 'conflict', diagnostics: planned.diagnostics });
+      const wrapper = original.wrapper;
+      const stylesheetFile = wrapper?.contract.stylesheet;
+      const reconciled = reconcileJsxStructurePlan({
+        file, baseline: { sourceRevision: target.sourceRevision, source: baselineInputs[file], identity: original.identity },
+        external: { sourceRevision: target.sourceRevision, source: externalInputs[file], sha256: hash(externalInputs[file]), identity: latest.identity },
+        operations: planned.operations, allowedFiles: wrapper ? [file, stylesheetFile] : [file],
+        ...(wrapper ? { wrapper: { contract: wrapper.contract, baselineSource: baselineInputs[stylesheetFile], externalSource: externalInputs[stylesheetFile], externalSha256: hash(externalInputs[stylesheetFile]) } } : {}),
+      });
+      if (reconciled.status === 'conflict') return reconciled;
+      const projection = reimportJsxStructureSource({ file, source: reconciled.source, identity: reconciled.identity,
+        ...(wrapper ? { wrapper: { contract: wrapper.contract, source: reconciled.stylesheetSource ?? externalInputs[stylesheetFile] } } : {}) });
+      verifyProjection(document, projection);
+      const current = capture(await loadBaseline(freeze({ target, sourceInputs: externalInputs, projectedStructure: latest.projectedStructure }), signal));
+      signal?.throwIfAborted();
+      verifyProofs(current.mapping, externalInputs);
+      if (!same(current.document, baseline.document)) fail('source-document-conflict', 'The current source projection changed the original document contract.');
+      const checked = compileDocumentSource({ target, before: current.document, after: document, mapping: current.mapping });
+      if (checked.status === 'blocked') return freeze({ status: 'conflict', diagnostics: checked.diagnostics });
+      signal?.throwIfAborted();
+      return freeze({ status: 'ready', baseline: JSON.parse(fingerprint(current)), document });
+    } catch (error) {
+      signal?.throwIfAborted();
+      return freeze({ status: 'conflict', diagnostics: error?.diagnostics ?? [{ code: 'source-reconcile-invalid', message: error instanceof Error ? error.message : String(error) }] });
+    }
+  }
+  return Object.freeze({ projectInputs, reconcile });
+}