uniweb 1.13.0 → 1.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "1.13.0",
+  "version": "1.13.1",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -41,10 +41,10 @@
     "js-yaml": "^4.1.0",
     "prompts": "^2.4.2",
     "tar": "^7.0.0",
-    "@uniweb/schemas": "~1.5.0",
     "@uniweb/content-writer": "~1.3.0",
-    "@uniweb/core": "~1.3.0",
-    "@uniweb/semantic-parser": "~1.12.0"
+    "@uniweb/schemas": "~1.5.0",
+    "@uniweb/semantic-parser": "~1.12.0",
+    "@uniweb/core": "~1.3.0"
   },
   "peerDependencies": {
     "@uniweb/content-reader": "~1.5.2",

package/src/backend/site-sync.js

@@ -23,6 +23,7 @@ import {
   uncommittedPaths,
   commitRoots,
   gitError,
+  RECORDED_TRAILER,
   unmergedPaths,
   mergeInProgress
 } from '../utils/sync-point.js'
@@ -1071,6 +1072,20 @@ export function uncommittedContent(siteDir, { verb = 'push' } = {}) {
       lines: [`Finish it (\`git commit\`), then ${verb} — or abandon it (\`git merge --abort\`) and pull again.`]
     }
   }
+  // ⭐ A repository with no commit yet is still the one that will hold the site's history —
+  // and holds none of it, so every file is listed as not committed. Said as that, not as
+  // edits. ⛔ Not taken for a folder outside git: its first push would keep nothing to merge
+  // from, and the pull after its first commit would read every difference as a conflict.
+  if (!repo.head) {
+    return {
+      paths,
+      headline: `Not ${done} — this repository has no commit yet, so none of the site's ${paths.length} file(s) is committed.`,
+      lines: [
+        `In a repository a ${verb} sends what you have committed, so a later pull can tell your changes from the backend's.`,
+        `Commit the site, then ${verb} again — or re-run with --commit (and -m "…") to make that first commit.`
+      ]
+    }
+  }
   return {
     paths,
     headline: `Not ${done} — ${paths.length} file(s) of the site are not committed:`,
@@ -1139,8 +1154,11 @@ export function commitWriteBacks(siteDir, backend, { complete = false } = {}) {
     GIT_COMMITTER_EMAIL: `sync@${host}`
   }
   try {
+    // ⭐ Marked with the backend and the site, so a pull reads the commit a lane names through
+    // it (`recordedAfter`, utils/sync-point.js): the ids written back are what the backend holds.
+    const site = readBackendState(siteDir, backend).site?.uuid
     const made = commitRoots(repo, [...sentRoots(siteDir), SYNC_STORE_FILE], {
-      message: `Record what ${backend} gave the site`,
+      message: `Record what ${backend} gave the site${site ? `\n\n${RECORDED_TRAILER}: ${backend} ${site}` : ''}`,
       identity
     })
     if (made && complete) writeSyncPoint(siteDir, backend, made.commit)

package/src/commands/pull.js

@@ -115,7 +115,7 @@ import {
   isAncestor,
   historySyncPoint,
   madeOnto,
-  newestBase,
+  baseFor,
   openStandIn,
   mergeSyncPoint,
   takeSyncPoint,
@@ -914,13 +914,15 @@ export async function pull(args = [], deps = {}) {
     ]
     const laneRoots = siteLaneRoots(siteDir)
     const taken = (lane) => lane && !lane.notModified && !lane.refused
-    base = newestBase(repo, [...known, content?.source, folderLane?.source], {
+    base = baseFor(repo, {
       known,
-      // ⛔ Each lane the backend answered holds every base to what it names (`newestBase`).
+      // ⛔ What each lane the backend answered names is a base only where every lane holds it (`baseFor`).
       lanes: [
         ...(taken(content) ? [{ source: content.source, roots: laneRoots.content }] : []),
         ...(taken(folderLane) ? [{ source: folderLane.source, roots: laneRoots.records }] : [])
-      ]
+      ],
+      origin: client.origin,
+      siteUuid: siteContentUuid
     })
     onto = force || !base ? repo.head : base
     try {
@@ -1183,6 +1185,8 @@ export async function pull(args = [], deps = {}) {
         } else {
           merge.conflicted = result.conflicted || []
           merge.stashKept = Boolean(result.stashKept)
+          // Whether anything was set aside for the merge: the files as they were, against HEAD.
+          merge.setAside = files !== repo.head
           merge.noBase = !force && !base
           merge.changed = changedInFiles(repo, {
             from: repo.head,
@@ -1286,7 +1290,9 @@ export async function pull(args = [], deps = {}) {
           note("your changes from the backend's: each file where they differ is a conflict, yours against the backend's.")
           note('Once this merge is committed, later pulls merge from it.')
         }
-        note('Settle them and `git add` each, then `git commit` to finish the merge — your uncommitted changes come back with it.')
+        note(
+          `Settle them and \`git add\` each, then \`git commit\` to finish the merge${merge.setAside ? ' — your uncommitted changes come back with it' : ''}.`
+        )
       }
     }
   }

package/src/utils/sync-point.js

@@ -53,6 +53,8 @@ import { join, dirname } from 'node:path'
 
 export const SYNC_TRAILER = 'Uniweb-Sync'
 export const SITE_TRAILER = 'Uniweb-Site'
+/** Marks the commit a push makes of what it wrote back: `Uniweb-Recorded: <origin> <site>`. */
+export const RECORDED_TRAILER = 'Uniweb-Recorded'
 
 const MAX_BUFFER = 1024 * 1024 * 1024
 
@@ -280,24 +282,8 @@ export function madeOnto(repo, sha, { origin, siteUuid }) {
  * reads the old text, so the change-back looks like no change at all. ⛔ Until
  * 2026-10-17 this said an older base "costs precision at worst".
  */
-export function newestBase(repo, candidates, { lanes = null, known = [] } = {}) {
-  let shas = [...new Set(candidates.filter(Boolean))].filter((s) => isCommit(repo, s) && isAncestor(repo, s))
-  // ⛔ ONE MERGE TAKES ONE BASE FOR EVERY LANE, and a lane's own source says what that lane
-  // holds. A commit newer than it whose content differs there reads what the lane lacks — a
-  // push of it the backend refused while it took the other lane — as the backend's removal,
-  // and the merge drops it. A lane that names no source is held to the newest of the bases
-  // this copy knows of itself; with none, only those can be the base.
-  if (lanes?.length) {
-    const own = new Set(known.filter(Boolean))
-    const fallback = newestBase(repo, known)
-    shas = shas.filter((s) =>
-      lanes.every(({ source, roots }) => {
-        const ref = source && isCommit(repo, source) && isAncestor(repo, source) ? source : fallback
-        if (!ref) return own.has(s)
-        return s === ref || isAncestor(repo, s, ref) || !differsIn(repo, ref, s, roots)
-      })
-    )
-  }
+export function newestBase(repo, candidates) {
+  const shas = [...new Set(candidates.filter(Boolean))].filter((s) => isCommit(repo, s) && isAncestor(repo, s))
   if (shas.length <= 1) return shas[0] || null
   const newest = shas.find((s) => shas.every((o) => o === s || isAncestor(repo, o, s)))
   if (newest) return newest
@@ -308,6 +294,60 @@ export function newestBase(repo, candidates, { lanes = null, known = [] } = {})
   }
 }
 
+/**
+ * The base a pull merges from, given the bases this copy knows of itself and what the backend
+ * names for each lane it answered (`x-uniweb-source`).
+ *
+ * ⭐ THIS COPY'S OWN BASES ARE EXACT BY CONSTRUCTION — a pull's commit, the commit a push was
+ * made from once every lane landed, one a push found nothing to send from — and are never
+ * second-guessed here.
+ *
+ * ⛔ ONE MERGE TAKES ONE BASE FOR EVERY LANE, and what the backend names is exact for its own
+ * lane only. A commit one lane names that is newer than another lane's, with that lane's files
+ * different, would read what that lane lacks — a push of it the backend refused while it took the
+ * other — as the backend's removal, and the merge would drop it. So it is not a base. A lane is
+ * held to the commit it names, read through the commit its push made of what it wrote back
+ * (`recordedAfter`), and a lane that names none to the newest base this copy knows.
+ *
+ * ⛔ Until 2026-10-19 (cli 713f62d, uniweb 1.13.0) every candidate was held to that, this copy's
+ * own included, and a lane to the commit it names alone. A first push writes each new record's
+ * `$uuid` back, so the records differed from the commit the folder lane names in every commit after
+ * it, and each was dropped: a pull merged from the site's first push, measured by flows against a
+ * real backend — a reverted change came back (A18), a re-wrap and six pushed edits conflicted.
+ */
+export function baseFor(repo, { known = [], lanes = [], origin, siteUuid }) {
+  const held = (s) => Boolean(s) && isCommit(repo, s) && isAncestor(repo, s)
+  const fallback = newestBase(repo, known)
+  const refs = lanes.map(({ source, roots }) => ({
+    roots,
+    ref: held(source) ? recordedAfter(repo, source, { origin, siteUuid }) || source : fallback
+  }))
+  const named = lanes.flatMap(({ source }) => (held(source) ? [source, recordedAfter(repo, source, { origin, siteUuid })] : []))
+  const taken = named.filter(Boolean).filter((s) =>
+    refs.every(({ ref, roots }) => Boolean(ref) && (s === ref || isAncestor(repo, s, ref) || !differsIn(repo, ref, s, roots)))
+  )
+  return newestBase(repo, [...known, ...taken])
+}
+
+/**
+ * The commit a push made of what it wrote back, after being made from `sha` — its first parent,
+ * marked with the push's backend and site — when HEAD's history holds it; else null.
+ */
+export function recordedAfter(repo, sha, { origin, siteUuid }) {
+  if (!sha || !origin || !siteUuid) return null
+  let out
+  try {
+    out = gitText(repo.top, ['log', '--fixed-strings', `--grep=${RECORDED_TRAILER}: ${origin} ${siteUuid}`, '--format=%H %P', 'HEAD'])
+  } catch {
+    return null
+  }
+  for (const line of out.split('\n')) {
+    const [commit, first] = line.trim().split(' ')
+    if (commit && first && (first === sha || first.startsWith(sha))) return commit
+  }
+  return null
+}
+
 /** Does the content under `roots` differ between two commits? Anything but "no" counts as yes. */
 function differsIn(repo, a, b, roots) {
   try {