@volter/world-runtime 2.0.15 → 2.0.16

package/dist/src/served-world.js

@@ -156,7 +156,8 @@ export async function mountWorld(name, opts = {}) {
     const world = new WorldDoors(name, worldRoot, configRef, served, host, held('token') ?? mintToken('tok_'), held('token.read') ?? mintToken('tok_r_'));
     const keep = () => { writeSecret(join(worldRoot, stateDirName(), 'token'), world.token); writeSecret(join(worldRoot, stateDirName(), 'token.read'), world.readToken); };
     let timers = [];
-    return {
+    let stopping = null;
+    const mounted = {
         name, served, root: worldRoot,
         get token() { return world.token; }, get readToken() { return world.readToken; },
         twins: () => world.twins(),
@@ -193,18 +194,40 @@ export async function mountWorld(name, opts = {}) {
                 throw error;
             }
         },
-        async stop() {
-            for (const t of timers)
-                clearInterval(t);
-            try {
-                rmSync(record, { force: true });
-            }
-            catch { /* already gone */ }
-            const result = await downWorld(name, worldRoot);
-            if (result.externalErrors.length)
-                throw new Error(`World "${name}" shutdown incomplete; instance and reservation retained: ${result.externalErrors.join('; ')}`);
+        stop() {
+            // one stop at a time: a second caller (the view shutting down while a switch stops this World) shares the first's
+            stopping ??= stopOnce().finally(() => { stopping = null; });
+            return stopping;
         },
     };
+    async function stopOnce() {
+        // refreshes stop first, so none writes into the World while its twins stop; the serve record goes only once they are
+        // down. A stop that fails keeps the record (a checkout under the serve still refuses) and re-arms the refreshes:
+        // refused before anything stopped, the World is served as it was; failed part way, its record names what remains
+        for (const t of timers)
+            clearInterval(t);
+        timers = [];
+        let result;
+        try {
+            result = await downWorld(name, worldRoot);
+            if (result.externalErrors.length)
+                throw new Error(`World "${name}" shutdown incomplete; instance and reservation retained: ${result.externalErrors.join('; ')}`);
+        }
+        catch (error) {
+            if (instance) {
+                try {
+                    timers = await scheduleRefreshes(name, worldRoot, instance);
+                }
+                catch { /* the stop's error is the one reported */ }
+            }
+            throw error;
+        }
+        try {
+            rmSync(record, { force: true });
+        }
+        catch { /* already gone */ }
+    }
+    return mounted;
 }
 /** A local World's mirrors: each pack's builders, found once per process, and each client built once. */
 const localMirrors = new Map();

package/dist/src/world-view.js

@@ -55,17 +55,8 @@ export async function serveWorldView(name, opts = {}) {
         switching = true;
         const from = world.name;
         try {
-            // a stop that fails part way brings this branch back as it was before the error is reported
-            try {
-                await world.stop();
-            }
-            catch (error) {
-                try {
-                    await world.boot(url);
-                }
-                catch { /* the stop's own error is the one reported */ }
-                throw error;
-            }
+            // a stop that is refused or fails leaves this branch served as it was (served-world.ts stop): the switch just fails
+            await world.stop();
             let next;
             try {
                 next = await mountWorld(branch, mountOpts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/world-runtime",
-  "version": "2.0.15",
+  "version": "2.0.16",
   "description": "World configs for twins: boot named local runtimes, allocate ports, generate world.env/instance.json, and run apps against fake-key twin worlds.",
   "keywords": [
     "twin",
@@ -67,14 +67,14 @@
     "node": ">=22.3"
   },
   "peerDependencies": {
-    "@volter/world-core": "2.0.9",
+    "@volter/world-core": "2.0.10",
     "@volter/world-console": "2.0.9"
   },
   "dependencies": {
     "@electric-sql/pglite": "0.5.8",
     "@electric-sql/pglite-pgvector": "0.0.9",
     "@volter/world-access": "2.0.1",
-    "@volter/world-core": "2.0.9",
+    "@volter/world-core": "2.0.10",
     "pg-gateway": "0.3.0-beta.4",
     "smol-toml": "^1.8.0"
   },
@@ -84,6 +84,6 @@
     }
   },
   "optionalDependencies": {
-    "@volter/twin-mongodb": "0.1.9"
+    "@volter/twin-mongodb": "0.1.10"
   }
 }

package/src/served-world.ts

@@ -161,7 +161,8 @@ export async function mountWorld(name: string, opts: { /** the platforms whose p
   const world = new WorldDoors(name, worldRoot, configRef, served, host, held('token') ?? mintToken('tok_'), held('token.read') ?? mintToken('tok_r_'));
   const keep = (): void => { writeSecret(join(worldRoot, stateDirName(), 'token'), world.token); writeSecret(join(worldRoot, stateDirName(), 'token.read'), world.readToken); };
   let timers: ReturnType<typeof setInterval>[] = [];
-  return {
+  let stopping: Promise<void> | null = null;
+  const mounted: MountedWorld = {
     name, served, root: worldRoot,
     get token() { return world.token; }, get readToken() { return world.readToken; },
     twins: () => world.twins(),
@@ -188,13 +189,29 @@ export async function mountWorld(name: string, opts: { /** the platforms whose p
         throw error;
       }
     },
-    async stop() {
-      for (const t of timers) clearInterval(t);
-      try { rmSync(record, { force: true }); } catch { /* already gone */ }
-      const result = await downWorld(name, worldRoot);
-      if (result.externalErrors.length) throw new Error(`World "${name}" shutdown incomplete; instance and reservation retained: ${result.externalErrors.join('; ')}`);
+    stop() {
+      // one stop at a time: a second caller (the view shutting down while a switch stops this World) shares the first's
+      stopping ??= stopOnce().finally(() => { stopping = null; });
+      return stopping;
     },
   };
+  async function stopOnce(): Promise<void> {
+      // refreshes stop first, so none writes into the World while its twins stop; the serve record goes only once they are
+      // down. A stop that fails keeps the record (a checkout under the serve still refuses) and re-arms the refreshes:
+      // refused before anything stopped, the World is served as it was; failed part way, its record names what remains
+      for (const t of timers) clearInterval(t);
+      timers = [];
+      let result: Awaited<ReturnType<typeof downWorld>>;
+      try {
+        result = await downWorld(name, worldRoot);
+        if (result.externalErrors.length) throw new Error(`World "${name}" shutdown incomplete; instance and reservation retained: ${result.externalErrors.join('; ')}`);
+      } catch (error) {
+        if (instance) { try { timers = await scheduleRefreshes(name, worldRoot, instance); } catch { /* the stop's error is the one reported */ } }
+        throw error;
+      }
+      try { rmSync(record, { force: true }); } catch { /* already gone */ }
+  }
+  return mounted;
 }
 
 /** A local World's mirrors: each pack's builders, found once per process, and each client built once. */

package/src/world-view.ts

@@ -55,11 +55,8 @@ export async function serveWorldView(name: string, opts: { root?: string; port?:
     switching = true;
     const from = world.name;
     try {
-      // a stop that fails part way brings this branch back as it was before the error is reported
-      try { await world.stop(); } catch (error) {
-        try { await world.boot(url); } catch { /* the stop's own error is the one reported */ }
-        throw error;
-      }
+      // a stop that is refused or fails leaves this branch served as it was (served-world.ts stop): the switch just fails
+      await world.stop();
       let next: MountedWorld;
       try {
         next = await mountWorld(branch, mountOpts);