mapples 0.2.0-beta.3 → 0.2.0-beta.5

package/dist/services/syncEngine.js

@@ -13,10 +13,11 @@ import { codemodAdopt, extract, patch, upsertImports } from '@mapples/sid-ast';
 import { isNetworkError } from '../api/client.js';
 import { buildEnvelope, commitWithTransportRetry, mintCid, mintTxId, resolveCids, } from '../api/commit.js';
 import { HeadMismatchError, JpatchError } from '../api/errors.js';
+import { planTransactions } from '../api/txPlan.js';
 import { pullDelta, SnapshotRequired } from '../api/poll.js';
 import { fetchProjectState, } from '../api/objects.js';
 import { PRIMITIVE_MAPPING } from '../adopt/mappingTable.js';
-import { emitComponent, emitPage } from '../codegen/emit.js';
+import { emitComponent, emitPage, withoutRouteMarker } from '../codegen/emit.js';
 import { importNeedsFor } from '../codegen/imports.js';
 import { instanceLinker } from '../codegen/instances.js';
 import { deprecateFile } from '../merge/deprecate.js';
@@ -35,8 +36,10 @@ import { mintEntityFile } from '../nav/placement.js';
 import { syncNavigation } from '../nav/routeTree.js';
 import { syncStyleFile } from '../style/theme.js';
 import { emptyReport } from '../ui/report.js';
+import { sourceIdFor, } from '../types.js';
 const MAX_REBASE_RETRIES = 5;
-const MAX_OPS_PER_TX = 200;
+/** Source ops carry whole files (≤256 KiB each): fewer per transaction than node ops. */
+const SOURCE_OPS_PER_TX = 10;
 // buildRemoteModel needs the project root to read the stored head; carried as
 // a non-enumerable tag so BaseSnapshot's shape stays unchanged for callers.
 const ROOT_TAG = Symbol('projectRoot');
@@ -65,8 +68,9 @@ export async function runSyncEngine({ root, client }) {
     let currentSeq = head.seq;
     for (const entry of outbox.list()) {
         const progress = newProgress(currentHead, currentSeq);
+        const entryTxs = planTransactions(entry.ops);
         try {
-            await pushChunked(client, entry.ops, entry.txId, progress, { rebaseInPlace: true, report });
+            await pushChunked(client, entryTxs, entry.txId, progress, { rebaseInPlace: true, report });
             currentHead = progress.head;
             currentSeq = progress.seq;
             outbox.clear(entry.txId);
@@ -80,7 +84,7 @@ export async function runSyncEngine({ root, client }) {
                     outbox.clear(entry.txId);
                     outbox.park({
                         txId: mintTxId(),
-                        ops: resolveCids(entry.ops.slice(progress.committedOps), progress.idMap),
+                        ops: resolveCids(entryTxs.flat().slice(progress.committedOps), progress.idMap),
                         parkedAt: entry.parkedAt,
                     });
                 }
@@ -112,27 +116,62 @@ export async function runSyncEngine({ root, client }) {
     let txId = mintTxId();
     let attempt = 0;
     for (;;) {
-        const { pushOps, mergedBase, pagesMap, componentsMap } = await mergeAndWrite(root, client, config, base, remote, report);
-        if (pushOps.length === 0) {
+        const merged = await mergeAndWrite(root, client, config, base, remote, report);
+        const { mergedBase, pagesMap, componentsMap, sourceUploads } = merged;
+        // Planned before anything is sent: a placement group that cannot fit one
+        // transaction stops the push here (RFC-0001 §5.2). `pushOps` is the send
+        // order, which is what `progress.committedOps` counts against.
+        const pushTxs = planTransactions(merged.pushOps);
+        const pushOps = pushTxs.flat();
+        // Source text goes out AFTER the node ops (its `$sid`s must be server
+        // ids, which the node push mints), as its own transaction(s).
+        let sourceOps = [];
+        if (pushOps.length === 0 && sourceUploads.size === 0) {
             finalize(root, baseStore, mergedBase, pagesMap, componentsMap, remote.head, remote.seq);
             report.head = remote.head;
             return report;
         }
-        if (pushOps.length > MAX_OPS_PER_TX) {
+        if (pushTxs.length > 1) {
             // Split into sequential transactions (RFC-0001 §5.1 TX_TOO_LARGE discipline).
-            report.notes.push(`push split into ${Math.ceil(pushOps.length / MAX_OPS_PER_TX)} transactions`);
+            report.notes.push(`push split into ${pushTxs.length} transactions`);
         }
         const progress = newProgress(remote.head, remote.seq);
         try {
-            await pushChunked(client, pushOps, txId, progress, {
-                rebaseInPlace: false,
-                report,
-                // Rewrite as each chunk lands, so files and base never hold a cid the
-                // server has already resolved: a re-merge or a park after a later
-                // chunk fails then sees the committed nodes by their real ids.
-                onChunk: (idMap) => rewriteIds(root, mergedBase, [pagesMap, componentsMap], idMap, report),
-            });
-            report.pushedOps += pushOps.length;
+            if (pushOps.length > 0) {
+                await pushChunked(client, pushTxs, txId, progress, {
+                    rebaseInPlace: false,
+                    report,
+                    // Rewrite as each chunk lands, so files and base never hold a cid the
+                    // server has already resolved: a re-merge or a park after a later
+                    // chunk fails then sees the committed nodes by their real ids.
+                    onChunk: (idMap) => rewriteIds(root, mergedBase, [pagesMap, componentsMap], idMap, report),
+                });
+                report.pushedOps += pushOps.length;
+            }
+            sourceOps = sourceOpsFor(mergedBase, remote, sourceUploads, progress.idMap);
+            try {
+                for (let i = 0; i < sourceOps.length; i += SOURCE_OPS_PER_TX) {
+                    await pushChunked(client, [sourceOps.slice(i, i + SOURCE_OPS_PER_TX)], pushOps.length === 0 && i === 0 ? txId : mintTxId(), progress, { rebaseInPlace: false, report });
+                }
+                if (sourceOps.length > 0) {
+                    report.pushedOps += sourceOps.length;
+                    report.notes.push(`uploaded the source text of ${sourceOps.length} file(s) to Creator`);
+                }
+            }
+            catch (err) {
+                if (!(err instanceof JpatchError && err.code === 'UNKNOWN_ENTITY'))
+                    throw err;
+                // A Creator server from before A12 rejects the entity. The node ops
+                // already landed; the code stays local and is offered again once the
+                // server stores source text — never silently.
+                for (const id of sourceUploads) {
+                    const entry = mergedBase.sources.get(progress.idMap[id] ?? id);
+                    if (entry)
+                        entry.onServer = false;
+                }
+                sourceOps = [];
+                report.notes.push('this Creator server does not store source text yet — the code around your elements stays local until it does');
+            }
             finalize(root, baseStore, mergedBase, pagesMap, componentsMap, progress.head, progress.seq);
             report.head = progress.head;
             return report;
@@ -157,12 +196,15 @@ export async function runSyncEngine({ root, client }) {
                 // Files already show the merged view; park what did not land (with
                 // the committed chunks' cids resolved) and adopt the remote head so
                 // the drain pushes exactly these ops next time.
+                // Source ops not yet computed (offline during the node push) are
+                // simply recomputed next time: the files still differ from the base.
+                const allOps = [...pushOps, ...sourceOps];
                 outbox.park({
                     txId: progress.committedOps > 0 ? mintTxId() : txId,
-                    ops: resolveCids(pushOps.slice(progress.committedOps), progress.idMap),
+                    ops: resolveCids(allOps.slice(progress.committedOps), progress.idMap),
                     parkedAt: new Date().toISOString(),
                 });
-                report.pushedOps = pushOps.length;
+                report.pushedOps = allOps.length;
                 report.offline = true;
                 finalize(root, baseStore, remoteAsBase(remote), readPagesMap(root), readComponentsMap(root), remote.head, remote.seq);
                 return report;
@@ -182,26 +224,33 @@ async function bootstrap(root, client, config, report) {
     const componentsMap = readComponentsMap(root);
     placeComponents(config.componentsDir ?? DEFAULT_COMPONENTS_DIR, state.components, componentsMap);
     const linker = instanceLinker(componentsMap, state.components);
+    // A container with stored source text (A12) materializes from that text —
+    // hooks and handlers written in the Creator's editor included — patched to
+    // its current tree; the rest is generated.
     const targets = [];
     for (const page of state.pages.values()) {
         const mapping = pagesMap[page.id];
         if (!mapping)
             throw new Error(`internal: page ${page.id} was not placed`);
+        const tree = linker.unlink(page.root, mapping.file, warnInto(report, mapping.file));
         targets.push({
+            id: page.id,
             file: mapping.file,
-            emit: () => emitPage(emitInput(page.name, linker.unlink(page.root, mapping.file, warnInto(report, mapping.file)), mapping), join(root, mapping.file)),
+            emit: async () => renderFromSource(state.sources.get(page.id) ?? null, tree, mapping.file, report) ??
+                emitPage(emitInput(page.name, tree, mapping), join(root, mapping.file)),
         });
     }
     for (const component of state.components.values()) {
         const mapping = componentsMap[component.id];
+        const tree = linker.unlink(component.root, mapping.file, warnInto(report, mapping.file));
         targets.push({
+            id: component.id,
             file: mapping.file,
-            emit: () => emitComponent({
-                name: component.name,
-                root: linker.unlink(component.root, mapping.file, warnInto(report, mapping.file)),
-            }, join(root, mapping.file)),
+            emit: async () => renderFromSource(state.sources.get(component.id) ?? null, tree, mapping.file, report) ??
+                emitComponent({ name: component.name, root: tree }, join(root, mapping.file)),
         });
     }
+    const baseSources = new Map();
     for (const target of targets) {
         const filePath = join(root, target.file);
         if (existsSync(filePath)) {
@@ -211,11 +260,23 @@ async function bootstrap(root, client, config, report) {
                 action: 'unchanged',
                 detail: 'exists — left untouched',
             });
-            continue;
         }
-        mkdirSync(dirname(filePath), { recursive: true });
-        writeFileSync(filePath, await target.emit());
-        report.files.push({ file: target.file, action: 'created' });
+        else {
+            mkdirSync(dirname(filePath), { recursive: true });
+            writeFileSync(filePath, await target.emit());
+            report.files.push({ file: target.file, action: 'created' });
+        }
+        // The text 3-way's base: the server's text where it has one, else the
+        // file as it stands (an untouched pre-existing file included — its own
+        // code then reads as a local change and uploads on the next sync).
+        const remoteSource = state.sources.get(target.id) ?? null;
+        baseSources.set(target.id, {
+            id: remoteSource?.id ?? sourceIdFor(target.id),
+            of: target.id,
+            lang: remoteSource?.lang ?? 'tsx',
+            text: remoteSource?.text ?? readFileSync(filePath, 'utf8'),
+            onServer: remoteSource !== null,
+        });
     }
     const styleResult = syncStyleFile(root, state.style, state.style, report);
     const assetsResult = await syncAssets(root, client, state.assets, report);
@@ -228,6 +289,7 @@ async function bootstrap(root, client, config, report) {
         navigation: navResult.mergedNavigation,
         style: styleResult.mergedStyle,
         assets: state.assets,
+        sources: baseSources,
     });
     baseStore.writeStamp(state.head);
     writePagesMap(root, pagesMap);
@@ -287,6 +349,9 @@ async function buildRemoteModel(client, base, sinceSeq, report) {
             navigation: structuredClone(base.navigation),
             style: structuredClone(base.style),
             assets: structuredClone(base.assets),
+            sources: new Map([...base.sources]
+                .filter(([, source]) => source.onServer)
+                .map(([id, { onServer: _onServer, ...source }]) => [id, source])),
             head: storedHead.head,
             seq: storedHead.seq,
         };
@@ -299,6 +364,7 @@ async function buildRemoteModel(client, base, sinceSeq, report) {
         navigation: state.navigation,
         style: state.style,
         assets: state.assets,
+        sources: state.sources,
         head: state.head,
         seq: state.seq,
     };
@@ -309,12 +375,14 @@ async function mergeAndWrite(root, client, config, base, remote, report) {
     const pagesMap = readPagesMap(root);
     const componentsMap = readComponentsMap(root);
     const pushOps = [];
+    const sourceUploads = new Set();
     const mergedBase = {
         pages: new Map(),
         components: new Map(),
         navigation: remote.navigation,
         style: remote.style,
         assets: remote.assets,
+        sources: new Map(),
     };
     // Reset per-attempt report fields (the rebase loop re-runs this).
     report.files = [];
@@ -336,6 +404,10 @@ async function mergeAndWrite(root, client, config, base, remote, report) {
         linker,
         emit: (entity, mapping, tree, filePath) => emitPage(emitInput(entity.name, tree, mapping), filePath),
         mergedOut: mergedBase.pages,
+        baseSources: base.sources,
+        remoteSources: remote.sources,
+        sourcesOut: mergedBase.sources,
+        sourceUploads,
         pushOps,
         report,
     });
@@ -348,6 +420,10 @@ async function mergeAndWrite(root, client, config, base, remote, report) {
         linker,
         emit: (entity, _mapping, tree, filePath) => emitComponent({ name: entity.name, root: tree }, filePath),
         mergedOut: mergedBase.components,
+        baseSources: base.sources,
+        remoteSources: remote.sources,
+        sourcesOut: mergedBase.sources,
+        sourceUploads,
         pushOps,
         report,
     });
@@ -358,7 +434,7 @@ async function mergeAndWrite(root, client, config, base, remote, report) {
     const assetsResult = await syncAssets(root, client, remote.assets, report);
     pushOps.push(...assetsResult.pushOps);
     mergedBase.assets = assetsResult.mergedAssets;
-    return { pushOps, mergedBase, pagesMap, componentsMap };
+    return { pushOps, mergedBase, pagesMap, componentsMap, sourceUploads };
 }
 /**
  * The 3-way file merge for one entity kind: extract the file, merge against
@@ -366,7 +442,28 @@ async function mergeAndWrite(root, client, config, base, remote, report) {
  * deprecate on conflict, and collect the ops that push local changes.
  */
 async function mergeFiles(args) {
-    const { root, kind, base, remote, mapping: mappings, linker, emit, mergedOut, pushOps, report, } = args;
+    const { root, kind, base, remote, mapping: mappings, linker, emit, mergedOut, baseSources, remoteSources, sourcesOut, sourceUploads, pushOps, report, } = args;
+    /**
+     * The file's text after this sync becomes the next base. It goes to the
+     * server when a stored text exists and differs from the file (the file
+     * always wins: the merge above already folded the Creator's side in), or
+     * when the developer changed the code of a file the server has no text for.
+     */
+    const recordSource = (id, remoteSource, text, codeChanged) => {
+        const upload = remoteSource !== null ? remoteSource.text !== text : codeChanged;
+        if (upload)
+            sourceUploads.add(id);
+        sourcesOut.set(id, {
+            id: remoteSource?.id ?? sourceIdFor(id),
+            of: id,
+            lang: remoteSource?.lang ?? 'tsx',
+            text,
+            onServer: remoteSource !== null || upload,
+        });
+    };
+    /** A container's file text: its stored source patched to `tree`, else generated. */
+    const fileTextFor = async (entity, mapping, remoteSource, tree, filePath) => renderFromSource(remoteSource, tree, mapping.file, report) ??
+        (await emit(entity, mapping, tree, filePath));
     const ids = new Set([...base.keys(), ...remote.keys()]);
     for (const id of ids) {
         const baseEntity = base.get(id) ?? null;
@@ -380,12 +477,20 @@ async function mergeFiles(args) {
         }
         const filePath = join(root, mapping.file);
         const fileExists = existsSync(filePath);
+        const baseSource = baseSources.get(id) ?? null;
+        const remoteSource = remoteSources.get(id) ?? null;
         // local = fresh extract, with NON_LITERAL props refilled from base.
         let local;
         // The same tree as the file reads it (linked instances still Customs):
         // what edits to the file are computed against.
         let localFile = null;
         let fileSource = null;
+        /**
+         * The file as the developer left it, after import healing (a stripped
+         * import is an interrupted sync's damage, not a code edit) and before
+         * tagging (an element added without a `$sid` IS one).
+         */
+        let originalSource = null;
         if (fileExists) {
             fileSource = readFileSync(filePath, 'utf8');
             // Pre-extraction import healing: a file left behind by an interrupted
@@ -401,6 +506,7 @@ async function mergeFiles(args) {
                     report.notes.push(`${mapping.file}: restored missing imports before extraction`);
                 }
             }
+            originalSource = fileSource;
             // An element the developer added without a `$sid` is invisible to
             // extraction — and so to the Creator — for as long as it stays untagged.
             // Tag it the way adoption did the file: react-native primitives swapped
@@ -460,7 +566,9 @@ async function mergeFiles(args) {
                 report.conflicts.push({ ...c, file: mapping.file, deprecatedTo });
             if (remoteEntity) {
                 mkdirSync(dirname(filePath), { recursive: true });
-                writeFileSync(filePath, await emit(remoteEntity, mapping, linker.unlink(remoteEntity.root, mapping.file, warnInto(report, mapping.file)), filePath));
+                const regenerated = await fileTextFor(remoteEntity, mapping, remoteSource, linker.unlink(remoteEntity.root, mapping.file, warnInto(report, mapping.file)), filePath);
+                writeFileSync(filePath, regenerated);
+                recordSource(id, remoteSource, regenerated, false);
                 report.files.push({
                     file: mapping.file,
                     action: 'deprecated',
@@ -511,27 +619,76 @@ async function mergeFiles(args) {
         }
         // Write the merged view into the file — in the file's language.
         const mergedFile = linker.unlink(merged, mapping.file, warnInto(report, mapping.file));
-        if (fileExists && fileSource !== null && localFile !== null) {
-            const edits = treeToEdits(localFile, mergedFile);
-            // Import healing: patch-inserted elements must be importable, and files
-            // touched by an interrupted earlier sync may be missing imports already.
-            const healed = upsertImports(fileSource, importNeedsFor(mergedFile));
-            if (edits.length > 0 || healed !== fileSource) {
-                const { source: patched, warnings } = patch(healed, edits);
-                for (const w of warnings)
-                    report.warnings.push({ ...w, file: mapping.file });
-                writeFileSync(filePath, patched);
-                report.files.push({ file: mapping.file, action: 'updated' });
+        /** The file's text after this sync. */
+        let written;
+        /** The developer changed the file since the last sync (unknowable without a base). */
+        let localTextChanged = false;
+        if (fileExists && fileSource !== null && localFile !== null && originalSource !== null) {
+            // The text 3-way (A12): the code outside `$sid` elements. The
+            // document merge above already settled every element; here only the
+            // surrounding code is at stake. Remote wins when the developer left the
+            // file alone; both changed is a conflict, and P0 keeps the local file.
+            const remoteTextChanged = remoteSource !== null && baseSource !== null && remoteSource.text !== baseSource.text;
+            // Route markers are the CLI's own (placement rewrites them), never a code edit.
+            localTextChanged =
+                baseSource !== null &&
+                    withoutRouteMarker(originalSource) !== withoutRouteMarker(baseSource.text);
+            const fromRemote = remoteTextChanged && remoteSource !== null
+                ? renderFromSource(remoteSource, mergedFile, mapping.file, report)
+                : null;
+            if (fromRemote !== null) {
+                if (localTextChanged) {
+                    const deprecatedTo = relative(root, deprecateFile(filePath));
+                    report.conflicts.push({
+                        sid: mergedFile.sid,
+                        reason: 'source-text',
+                        detail: 'the code around the elements changed both here and in Creator',
+                        file: mapping.file,
+                        deprecatedTo,
+                    });
+                    report.files.push({
+                        file: mapping.file,
+                        action: 'deprecated',
+                        detail: `code conflict — your version kept at ${deprecatedTo}; Creator's code applied`,
+                    });
+                }
+                else {
+                    report.files.push({
+                        file: mapping.file,
+                        action: 'updated',
+                        detail: 'code edited in Creator',
+                    });
+                }
+                mkdirSync(dirname(filePath), { recursive: true });
+                writeFileSync(filePath, fromRemote);
+                written = fromRemote;
             }
             else {
-                report.files.push({ file: mapping.file, action: 'unchanged' });
+                const edits = treeToEdits(localFile, mergedFile);
+                // Import healing: patch-inserted elements must be importable, and files
+                // touched by an interrupted earlier sync may be missing imports already.
+                const healed = upsertImports(fileSource, importNeedsFor(mergedFile));
+                if (edits.length > 0 || healed !== fileSource) {
+                    const { source: patched, warnings } = patch(healed, edits);
+                    for (const w of warnings)
+                        report.warnings.push({ ...w, file: mapping.file });
+                    writeFileSync(filePath, patched);
+                    report.files.push({ file: mapping.file, action: 'updated' });
+                    written = patched;
+                }
+                else {
+                    report.files.push({ file: mapping.file, action: 'unchanged' });
+                    written = fileSource;
+                }
             }
         }
         else {
             mkdirSync(dirname(filePath), { recursive: true });
-            writeFileSync(filePath, await emit(remoteEntity, mapping, mergedFile, filePath));
+            written = await fileTextFor(remoteEntity, mapping, remoteSource, mergedFile, filePath);
+            writeFileSync(filePath, written);
             report.files.push({ file: mapping.file, action: fileExists ? 'regenerated' : 'created' });
         }
+        recordSource(id, remoteSource, written, localTextChanged);
         // Push = local changes rebased onto remote.
         pushOps.push(...diffTree(remoteRoot, merged));
         mergedOut.set(id, { ...remoteEntity, root: merged });
@@ -544,6 +701,65 @@ function warnInto(report, file) {
         report.warnings.push({ ...w, file });
     };
 }
+/**
+ * A container's stored source (A12) brought up to date with `tree` — the
+ * FILE-language tree the file must show: its `$sid` elements are re-patched
+ * from the document (which is the truth for them), everything around them is
+ * the text as stored. Null when the text holds no `$sid` root, which is
+ * reported and regenerated rather than silently guessed.
+ */
+function renderFromSource(source, tree, file, report) {
+    if (source === null)
+        return null;
+    const extracted = extract(source.text);
+    if (extracted.dom === null) {
+        report.notes.push(`${file}: the source stored in Creator has no $sid root — regenerated from the canvas instead`);
+        return null;
+    }
+    fillNonLiteralProps(extracted.dom, tree, extracted.warnings);
+    const healed = upsertImports(source.text, importNeedsFor(tree));
+    const edits = treeToEdits(extracted.dom, tree);
+    if (edits.length === 0)
+        return healed;
+    const { source: patched, warnings } = patch(healed, edits);
+    for (const w of warnings)
+        report.warnings.push({ ...w, file });
+    return patched;
+}
+/**
+ * Source ops for the containers the merge marked for upload: a create where
+ * the server has no Source yet, an update otherwise. `idMap` resolves
+ * containers created by the node push that just landed.
+ */
+function sourceOpsFor(mergedBase, remote, uploads, idMap) {
+    const ops = [];
+    for (const containerId of uploads) {
+        const serverId = idMap[containerId] ?? containerId;
+        if (serverId.startsWith('c_'))
+            continue; // its page never landed (offline): next sync
+        const source = mergedBase.sources.get(serverId);
+        if (!source)
+            throw new Error(`internal: no merged source for ${serverId}`);
+        const remoteSource = remote.sources.get(serverId) ?? null;
+        if (remoteSource === null) {
+            ops.push({
+                op: 'create',
+                entity: 'Source',
+                cid: mintCid(),
+                data: { of: serverId, lang: source.lang, text: source.text },
+            });
+        }
+        else if (remoteSource.text !== source.text) {
+            ops.push({
+                op: 'update',
+                entity: 'Source',
+                id: remoteSource.id,
+                patch: { text: source.text },
+            });
+        }
+    }
+    return ops;
+}
 /** NON_LITERAL_PROP contract: expression props keep their last-known base value. */
 function fillNonLiteralProps(local, baseRoot, warnings) {
     const baseIndex = new Map();
@@ -623,6 +839,17 @@ function rewriteIds(root, mergedBase, fileMaps, idMap, report) {
         renameTree(page.root);
     for (const component of mergedBase.components.values())
         renameTree(component.root);
+    // Source text mirrors the files: same rewrite, and a container minted by
+    // this push re-keys its entry under the server id.
+    const renamedSources = new Map();
+    for (const [containerId, source] of mergedBase.sources) {
+        let text = source.text;
+        for (const [cid, id] of entries)
+            text = text.split(`"${cid}"`).join(`"${id}"`);
+        const of = idMap[containerId] ?? containerId;
+        renamedSources.set(of, { ...source, id: sourceIdFor(of), of, text });
+    }
+    mergedBase.sources = renamedSources;
     if (mergedBase.assets) {
         mergedBase.assets = resolveAssetIds(mergedBase.assets, idMap);
         writeAssetMap(root, mergedBase.assets);
@@ -637,6 +864,7 @@ function remoteAsBase(remote) {
         navigation: remote.navigation,
         style: remote.style,
         assets: remote.assets,
+        sources: new Map([...remote.sources].map(([id, source]) => [id, { ...source, onServer: true }])),
     };
 }
 function finalize(root, baseStore, mergedBase, pagesMap, componentsMap, head, seq) {
@@ -650,22 +878,24 @@ function newProgress(head, seq) {
     return { head, seq, idMap: {}, committedOps: 0 };
 }
 /**
- * POST `ops` as sequential transactions of at most MAX_OPS_PER_TX (RFC-0001
- * §5.1 TX_TOO_LARGE discipline). cids are transaction-scoped (§5.2, invariant
- * 5): a later chunk may reference the nodes an earlier chunk created only by
- * their server ids, so every chunk is rewritten through the idMaps collected
+ * POST `txs` (planned by planTransactions, RFC-0001 §5.1/§5.2) as sequential
+ * transactions. cids are transaction-scoped (§5.2, invariant 5): a later
+ * transaction may reference the nodes an earlier one created only by their
+ * server ids, so every transaction is rewritten through the idMaps collected
  * so far before it is sent — otherwise the server answers CID_UNRESOLVED.
  *
- * `progress` advances after each committed chunk; when this throws, it tells
- * the caller exactly what already landed. The first chunk reuses `firstTxId`
- * (the caller's replay handle, RFC-0001 §7.3); later chunks mint their own.
- * `rebaseInPlace` retries a 409 on the same chunk from the server's head (the
- * outbox drain has nothing local to re-merge); otherwise the 409 propagates so
- * the caller can re-merge against the advanced remote.
+ * `progress` advances after each committed transaction; when this throws, it
+ * tells the caller exactly what already landed (`committedOps` counts against
+ * `txs.flat()`). The first transaction reuses `firstTxId` (the caller's replay
+ * handle, RFC-0001 §7.3); later ones mint their own. `rebaseInPlace` retries a
+ * 409 on the same transaction from the server's head (the outbox drain has
+ * nothing local to re-merge); otherwise the 409 propagates so the caller can
+ * re-merge against the advanced remote. Every op the server dropped and every
+ * warning it raised lands in the report.
  */
-async function pushChunked(client, ops, firstTxId, progress, opts) {
-    for (let i = 0; i < ops.length; i += MAX_OPS_PER_TX) {
-        const chunk = resolveCids(ops.slice(i, i + MAX_OPS_PER_TX), progress.idMap);
+async function pushChunked(client, txs, firstTxId, progress, opts) {
+    for (const [i, tx] of txs.entries()) {
+        const chunk = resolveCids(tx, progress.idMap);
         const txId = i === 0 ? firstTxId : mintTxId();
         let cursor = progress.head;
         let result;
@@ -687,9 +917,16 @@ async function pushChunked(client, ops, firstTxId, progress, opts) {
         progress.seq = result.seq;
         progress.idMap = { ...progress.idMap, ...result.idMap };
         progress.committedOps += chunk.length;
-        if (result.warnings?.length) {
-            for (const w of result.warnings)
-                opts.report.notes.push(`server warning: ${w}`);
+        for (const d of result.dropped ?? []) {
+            const op = chunk[d.index];
+            if (!op) {
+                throw new Error(`server dropped op ${d.index} of a ${chunk.length}-op transaction — server/CLI contract drift`);
+            }
+            opts.report.dropped.push({ ...d, op });
+        }
+        for (const w of result.warnings ?? []) {
+            if (!opts.report.serverWarnings.includes(w))
+                opts.report.serverWarnings.push(w);
         }
         opts.onChunk?.(result.idMap);
     }