mapples 0.2.0-beta.3 → 0.2.0-beta.4

package/dist/services/syncEngine.js

@@ -16,7 +16,7 @@ import { HeadMismatchError, JpatchError } from '../api/errors.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 +35,11 @@ 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');
@@ -112,8 +115,11 @@ 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 { pushOps, mergedBase, pagesMap, componentsMap, sourceUploads } = await mergeAndWrite(root, client, config, base, remote, report);
+        // 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;
@@ -124,15 +130,41 @@ export async function runSyncEngine({ root, client }) {
         }
         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, 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;
+            }
+            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 +189,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 +217,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 +253,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 +282,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 +342,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 +357,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 +368,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 +397,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 +413,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 +427,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 +435,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 +470,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 +499,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 +559,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 +612,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 +694,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 +832,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 +857,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) {