unoverse 0.1.162 → 0.1.164

package/lib/publish.mjs

@@ -81,9 +81,26 @@ export async function publish(args) {
     die(`no project "${project}" in ${designRoot}. Found: ${projects.join(", ") || "none"}`);
   }
 
-  // ── which universe: --to overrides, unoverse.yaml remembers, first run asks ─
+  // ── which universe: --to overrides, unoverse.yaml remembers, the login answers,
+  //    and only a machine that knows nothing asks ─────────────────────────────
   const config = await readConfig(ws.root);
   let universe = opt("to") ?? config.universe;
+  if (!universe) {
+    // THE LOGIN ALREADY NAMED THE UNIVERSE. `unoverse login` takes an address and
+    // keeps a session for it, so a machine signed in to exactly one universe has
+    // already answered this question — asking it again reads as the CLI forgetting
+    // what it was just told (observed live 2026-08-21). One session: use it, say so,
+    // and remember it in unoverse.yaml like a typed answer. Several sessions: the
+    // choice is real, so the question remains.
+    const { sessionOrigins } = await import("./session.mjs");
+    const origins = sessionOrigins();
+    if (origins.length === 1) {
+      universe = origins[0];
+      await writeConfig(ws.root, { universe });
+      console.log(`
+  ${c.dim}→ ${universe} (your signed-in universe; saved to unoverse.yaml)${c.off}`);
+    }
+  }
   if (!universe) {
     if (!process.stdin.isTTY) die("no universe. Pass --to https://your-universe.example, or commit it in unoverse.yaml");
     const typed = await ask(`\n  Where does this workspace deploy to? ${c.dim}(e.g. universe.example.com)${c.off} `);
@@ -123,7 +140,7 @@ export async function publish(args) {
   // ── 3. the plan: what would this publish actually do ────────────────────────
   let plan;
   try {
-    plan = await planPublish(items, universe, token);
+    plan = await planPublish(items, universe, token, project);
   } catch (e) {
     die(e.message);
   }
@@ -135,8 +152,10 @@ export async function publish(args) {
   for (const i of plan.update) console.log(`  ${c.yellow}~${c.off} ${label(i)} ${c.dim}(changed)${c.off}${pending(i)}`);
   if (plan.unchanged.length) console.log(`  ${c.dim}= ${plan.unchanged.length} unchanged${c.off}`);
   for (const r of plan.refused) console.log(`  ${c.red}✗ ${label(r)}${c.off} ${c.dim}${r.why}${c.off}`);
+  // Deploy is a SYNC: what left the workspace leaves the universe, said before it happens.
+  for (const r of plan.remove ?? []) console.log(`  ${c.red}-${c.off} ${label(r)} ${c.dim}(no longer in this workspace — will be removed)${c.off}`);
 
-  const toSend = plan.create.length + plan.update.length;
+  const toSend = plan.create.length + plan.update.length + (plan.remove?.length ?? 0);
   if (!toSend) {
     console.log(`\n  ${c.green}✓${c.off} nothing to do, ${project} is up to date\n`);
     process.exit(plan.refused.length ? 1 : 0);

package/lib/session.mjs

@@ -38,6 +38,11 @@ export function getSession(origin) {
   return load()[origin] ?? null;
 }
 
+/** Every universe origin this machine holds a session for. */
+export function sessionOrigins() {
+  return Object.keys(load());
+}
+
 export function saveSession(origin, session) {
   const all = load();
   all[origin] = session;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unoverse",
-  "version": "0.1.162",
+  "version": "0.1.164",
   "description": "The Unoverse front door — create a Studio project, a universe, or a client app, and launch Studio.",
   "license": "SEE LICENSE IN README.md",
   "type": "module",

package/vendor/base/items/publish.js

@@ -35,8 +35,41 @@ export async function lintForPublish(designRoot, project) {
  * owned by another publisher is refused, and finding that out before a publish beats
  * finding it out halfway through one.
  */
-export async function planPublish(items, universe, token, fetchImpl = fetch) {
-    const plan = { create: [], update: [], unchanged: [], refused: [] };
+export async function planPublish(items, universe, token, 
+/** The project being deployed; names the org whose universe rows the sync reconciles. */
+project = "", fetchImpl = fetch) {
+    const plan = { create: [], update: [], unchanged: [], refused: [], remove: [] };
+    /**
+     * DEPLOY IS A SYNC (ruled 2026-08-21): what the workspace no longer holds, the
+     * universe should not keep serving under this project's name. The universe lists its
+     * rows for the project; anything absent from the collected items joins the plan as a
+     * removal, shown and confirmed like everything else.
+     *
+     * ONE GUARD, against the catastrophic misread: a workspace that holds NO items for
+     * the project (a fresh clone missing its files, the wrong folder entirely) does not
+     * get to empty the universe. Removals are proposed only when the workspace holds at
+     * least one item — deleting the last one is done by name, deliberately.
+     */
+    if (project && items.length > 0) {
+        try {
+            const res = await fetchImpl(`${universe}/publish`, {
+                method: "POST",
+                headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+                body: JSON.stringify({ op: "list", project }),
+            });
+            if (res.ok) {
+                const doc = (await res.json().catch(() => null));
+                const have = new Set(items.map((i) => `${i.kind}/${i.name}`));
+                for (const r of doc?.items ?? []) {
+                    if (!have.has(`${r.kind}/${r.name}`))
+                        plan.remove.push(r);
+                }
+            }
+            // An older universe answers this op with an error: no removals proposed, the
+            // additive behavior every deploy had before. Never a failure.
+        }
+        catch { /* unreachable universe fails later, on the real sends */ }
+    }
     for (const item of items) {
         // ASK THE GATE, not the item store. `/api/items` is deliberately shut (§9.10), so a
         // publisher cannot read rows directly; and asking the publish route means the plan is
@@ -88,6 +121,20 @@ export async function sendPublish(plan, universe, token, fetchImpl = fetch) {
         else
             failed.push({ ...item, why: body.error ?? `HTTP ${res.status}` });
     }
+    // Removals LAST, after the writes landed: a sync that dies mid-run has then added
+    // before it has taken away, which is the recoverable order.
+    for (const r of plan.remove ?? []) {
+        const res = await fetchImpl(`${universe}/publish`, {
+            method: "POST",
+            headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+            body: JSON.stringify({ op: "remove", kind: r.kind, name: r.name }),
+        });
+        const body = (await res.json().catch(() => ({})));
+        if (res.ok)
+            sent.push({ ...r, mode: "removed" });
+        else
+            failed.push({ ...r, why: body.error ?? `HTTP ${res.status}` });
+    }
     return { sent, failed };
 }
 export { collectProject };