@volter/world 2.0.10 → 2.0.11

package/dist/src/world.d.ts

@@ -158,6 +158,9 @@ export declare class World {
     /** Switch to a branch: its twins come back with their state; this branch's stop. */
     checkout(name: string): Promise<World>;
     branches(): string[];
+    /** A served World stays bound to the branch it was served on: switching under it would leave its doors forwarding to
+     *  the stopped branch's twins. So a switch waits for the serve to stop. */
+    private refuseWhileServed;
     /** Is this the main branch? */
     isMain(): boolean;
     /** What this branch's changes are measured from, as `diff` says it: the branch point, origin, or the story. */

package/dist/src/world.js

@@ -256,6 +256,7 @@ export class World {
     async branch(name, opts = {}) {
         if (listWorlds(this.root).some((w) => w.name === name))
             throw new Error(`A branch "${name}" already exists — \`volter world checkout ${name}\` switches to it`);
+        this.refuseWhileServed('branch');
         // this branch stops first (a managed database is copied from a stopped World, and the two would share its port),
         // and comes back if the new one fails
         const wasRunning = !!this.instance()?.running;
@@ -280,6 +281,7 @@ export class World {
             return this;
         if (!listWorlds(this.root).some((w) => w.name === name))
             throw new Error(`No branch "${name}" in this world (branches: ${listWorlds(this.root).map((w) => w.name).sort().join(', ') || 'none'})`);
+        this.refuseWhileServed('checkout');
         const wasRunning = this.instance()?.running ?? false;
         if (wasRunning)
             await downWorld(this.name, this.root);
@@ -290,6 +292,13 @@ export class World {
         return target;
     }
     branches() { return listWorlds(this.root).map((w) => w.name).sort(); }
+    /** A served World stays bound to the branch it was served on: switching under it would leave its doors forwarding to
+     *  the stopped branch's twins. So a switch waits for the serve to stop. */
+    refuseWhileServed(verb) {
+        const served = readServeRecord(this.root);
+        if (served)
+            throw new Error(`this World is served at ${served.base} (pid ${served.pid}); stop that serve before \`volter world ${verb}\`, then serve again`);
+    }
     /** Is this the main branch? */
     isMain() { return this.name === mainBranch(this.root); }
     /** What this branch's changes are measured from, as `diff` says it: the branch point, origin, or the story. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/world",
-  "version": "2.0.10",
+  "version": "2.0.11",
   "description": "Run your app against a world of twins. `World` and `Repo` — one method per verb: init, up, run, log, diff, reset, branch, checkout, clone, fetch, changeset, push — and the `volter` command, one client of them.",
   "keywords": [
     "volter",

package/src/world.ts

@@ -241,6 +241,7 @@ export class World {
    */
   async branch(name: string, opts: { at?: { instant?: string; positions?: Record<string, number>; views?: Record<string, string> } } = {}): Promise<World> {
     if (listWorlds(this.root).some((w) => w.name === name)) throw new Error(`A branch "${name}" already exists — \`volter world checkout ${name}\` switches to it`);
+    this.refuseWhileServed('branch');
     // this branch stops first (a managed database is copied from a stopped World, and the two would share its port),
     // and comes back if the new one fails
     const wasRunning = !!this.instance()?.running;
@@ -259,6 +260,7 @@ export class World {
     if (name === 'main') name = mainBranch(this.root); // the main branch answers to its name and to `main`
     if (name === this.name) return this;
     if (!listWorlds(this.root).some((w) => w.name === name)) throw new Error(`No branch "${name}" in this world (branches: ${listWorlds(this.root).map((w) => w.name).sort().join(', ') || 'none'})`);
+    this.refuseWhileServed('checkout');
     const wasRunning = this.instance()?.running ?? false;
     if (wasRunning) await downWorld(this.name, this.root);
     const target = new World(name, this.root);
@@ -267,6 +269,12 @@ export class World {
     return target;
   }
   branches(): string[] { return listWorlds(this.root).map((w) => w.name).sort(); }
+  /** A served World stays bound to the branch it was served on: switching under it would leave its doors forwarding to
+   *  the stopped branch's twins. So a switch waits for the serve to stop. */
+  private refuseWhileServed(verb: 'branch' | 'checkout'): void {
+    const served = readServeRecord(this.root);
+    if (served) throw new Error(`this World is served at ${served.base} (pid ${served.pid}); stop that serve before \`volter world ${verb}\`, then serve again`);
+  }
   /** Is this the main branch? */
   isMain(): boolean { return this.name === mainBranch(this.root); }
   /** What this branch's changes are measured from, as `diff` says it: the branch point, origin, or the story. */