@volter/world-runtime 2.0.40 → 2.0.41

package/dist/src/branch.js

@@ -84,10 +84,12 @@ export async function branchWorld(base, name, options = {}) {
     }
     const forked = {};
     try {
-        if (from.origin) {
+        // the branch's origin is its base's, or none: never one a stopped World of the same name left
+        if (from.origin)
             instance.origin = { ...from.origin };
-            saveWorldInstance(instance);
-        }
+        else
+            delete instance.origin;
+        saveWorldInstance(instance);
         for (const { service, fromRoot, states } of source) {
             const toRoot = join(instance.dirs.data, service);
             for (const { state, generation, view, position: pos } of states) {

package/dist/src/origin.js

@@ -8,6 +8,7 @@ import { join, resolve } from 'node:path';
 import { getActiveWorldStore, readBranchMeta, withAncestryLock, writeBranchMeta } from '@volter/world-core';
 import { saveWorldInstance, statusWorld } from "./runtime.js";
 import { fetchReady, isPathRemote, localWorld, TOKEN_HEADER } from "./served-world.js";
+import { loadWorldConfig, writeWorldConfig } from "./configs.js";
 function originOf(instance, options) {
     const url = options.url ?? instance.origin?.url;
     const namespace = options.namespace ?? instance.origin?.namespace;
@@ -132,6 +133,20 @@ export async function fetchFromOrigin(name, options) {
         });
     }
     saveWorldInstance({ ...instance, origin: { ...origin, ...(options.full ? { clonedAt: at_ } : instance.origin?.clonedAt ? { clonedAt: instance.origin.clonedAt } : {}), fetchedAt: at_ } });
+    // a clone names its remote where `volter remote add` does (world.json, as git config holds a remote): one record of
+    // it, which every restart carries (runtime's namesOrigin) and `remote remove` ends. Only the World the config is
+    // for writes it: a runtime branch boots from its base's config, whose remote stays the base's
+    if (options.full && instance.name === instance.config) {
+        try {
+            const { path: configPath, config } = loadWorldConfig(instance.configPath, root);
+            const named = isPathRemote(origin.url) ? origin.url : `${origin.url}/${origin.namespace}`;
+            if (config.remotes?.origin !== named)
+                writeWorldConfig(configPath, { ...config, remotes: { ...(config.remotes ?? {}), origin: named } });
+        }
+        catch (error) {
+            console.error(`[origin] ${name}: the remote was not named in its config: ${error.message}`);
+        }
+    }
     return { world: name, origin, full: options.full ?? false, appended, behind, snapshots };
 }
 export function worldOrigin(name, root) {

package/dist/src/runtime.js

@@ -728,6 +728,22 @@ function writePidsFromInstance(instance, fresh = []) {
         ].filter((pid) => Number.isInteger(pid) && pid > 0))];
     writeOwnedPids(instance.root, instance.name, pids, fresh);
 }
+/** Whether a world.json remote (`https://<host>/<org>/<world>`, or a world's directory, relative to the World's root) is
+ *  the recorded origin, read as the CLI's parseOriginUrl reads it (the URL's origin, then its two path parts). */
+function namesOrigin(remote, origin, worldRoot) {
+    if (!remote)
+        return false;
+    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(remote))
+        return resolve(worldRoot, remote) === resolve(worldRoot, origin.url);
+    try {
+        const parsed = new URL(remote);
+        const parts = parsed.pathname.split('/').filter(Boolean);
+        return parts.length === 2 && parsed.origin === new URL(origin.url).origin && parts.join('/') === origin.namespace;
+    }
+    catch {
+        return false;
+    }
+}
 export function saveWorldInstance(instance) {
     writeTextAtomic(instanceFile(instance.root, instance.name), `${JSON.stringify(instance, null, 2)}\n`);
 }
@@ -1483,6 +1499,7 @@ export async function upWorld(configId, options = {}, abort) {
     const pidsFile = join(instance, 'pids');
     const envFile = resolve(root, options.envFile ?? join(instance, 'world.env'));
     const instanceFile = join(instance, 'instance.json');
+    let carriedOrigin;
     const priorOutputInstance = existsSync(instanceFile) ? JSON.parse(readFileSync(instanceFile, 'utf8')) : undefined;
     const priorOutput = priorOutputInstance?.name === name && resolve(priorOutputInstance.root) === root
         ? { path: resolve(priorOutputInstance.envFile), contents: envFileContents(priorOutputInstance.env) } : undefined;
@@ -1536,6 +1553,14 @@ export async function upWorld(configId, options = {}, abort) {
                     || !Number.isFinite(Date.parse(receipt.stoppedAt))) {
                     throw new Error(`World "${name}" has no verified teardown receipt for its prior instance; use its owning runtime to complete cleanup before replacement`);
                 }
+                // the origin belongs to the World, not to its running state (git: a remote outlives every checkout): an up of the
+                // same config carries the one the last left while world.json's `origin` remote still names it (`remote remove`
+                // ends it there; an instance under another World's config, a runtime branch, has only its own record); its cursors
+                // only when its state (the mirror they count) is kept, as reset drops them
+                if (prior.origin && prior.config === loaded.config.id && (name !== loaded.config.id || namesOrigin(loaded.config.remotes?.origin, prior.origin, root))) {
+                    carriedOrigin = options.keepState ? prior.origin
+                        : { url: prior.origin.url, namespace: prior.origin.namespace, ...(prior.origin.clonedAt ? { clonedAt: prior.origin.clonedAt } : {}) };
+                }
             }
             assertLifecycleStartable(root, name);
             beginWorldLifecycle(root, name, createdAt, options.owner);
@@ -1643,6 +1668,7 @@ export async function upWorld(configId, options = {}, abort) {
             ...(loaded.config.actors ? { actors: loaded.config.actors } : {}),
             ...(loaded.config.fixtures ? { fixtures: loaded.config.fixtures } : {}),
             lifecycle: { owner: options.owner, log: lifecycleLogPath(root, name) },
+            ...(carriedOrigin ? { origin: carriedOrigin } : {}),
         };
         saveWorldInstance(worldInstance);
         const cancelled = new AbortController();

package/dist/src/served-world.d.ts

@@ -268,6 +268,10 @@ export declare class WorldDoors {
     /** What this World issued, for world-access to decide a grant against: its two tokens, its named keys, its sessions. */
     private issued;
     private credential;
+    /** Each changeset's actions' receipts, from the landed copies on each twin's log: a deploy appends one per entry it
+     *  performed, and a push one per entry it landed at the remote (`landed` while the remote waits, beside the
+     *  changeset's own `applied`). */
+    private deployedOf;
     /** Who made a request, as this World names it: `key:<name>` for a named key, `person:<who>` for a browser's session
      *  (`person` when it names no one), `token` / `token:read` for the World's own tokens; null when it presented nothing
      *  this World issued. */

package/dist/src/served-world.js

@@ -658,6 +658,33 @@ export class WorldDoors {
             return { scope: grant.scope, via: 'session', token: null, session: grant.session, ...(grant.who ? { who: grant.who } : {}) };
         return { scope: grant.scope, via: grant.via === 'key' ? 'key' : 'token', token: grant.presented ?? null };
     }
+    /** Each changeset's actions' receipts, from the landed copies on each twin's log: a deploy appends one per entry it
+     *  performed, and a push one per entry it landed at the remote (`landed` while the remote waits, beside the
+     *  changeset's own `applied`). */
+    deployedOf(changesets) {
+        // by the state each action was written in (a twin may hold several), and a settled receipt wins over a provisional
+        // `landed` one whichever comes later in the log (a push's local copy, then the remote's deploy fetched in)
+        const landed = new Map();
+        const of = (service, state) => {
+            const at = `${service}\u0000${state}`;
+            let held = landed.get(at);
+            if (!held) {
+                held = new Map();
+                if (this.up().services[service]) {
+                    for (const e of parentEntries(state, this.controlRoot(service))) {
+                        if (!e.landsId || !e.receipt)
+                            continue;
+                        const before = held.get(e.landsId);
+                        if (!before || before.status === 'landed' || e.receipt.status !== 'landed')
+                            held.set(e.landsId, e.receipt);
+                    }
+                }
+                landed.set(at, held);
+            }
+            return held;
+        };
+        return changesets.map((c) => c.actions.flatMap((a) => { const r = of(a.service, a.stateService ?? this.stateOf(a.service)).get(a.action.id); return r ? [{ service: a.service, actionId: a.action.id, ...r }] : []; }));
+    }
     /** Who made a request, as this World names it: `key:<name>` for a named key, `person:<who>` for a browser's session
      *  (`person` when it names no one), `token` / `token:read` for the World's own tokens; null when it presented nothing
      *  this World issued. */
@@ -1198,9 +1225,11 @@ export class WorldDoors {
             // with the body's hash as it stands, so a reader sees an approval or a verification made on other bytes as stale
             if (name) {
                 const l = findWorldChangeset(name, { root: this.worldRoot, world: this.name });
-                return Response.json({ ...l.changeset, currentHash: changesetContentHash(l.changeset) });
+                return Response.json({ ...l.changeset, currentHash: changesetContentHash(l.changeset), deployed: this.deployedOf([l.changeset])[0] });
             }
-            return Response.json({ changesets: listWorldChangesets({ root: this.worldRoot, world: this.name }).map((l) => ({ ...l.changeset, currentHash: changesetContentHash(l.changeset) })) });
+            const all = listWorldChangesets({ root: this.worldRoot, world: this.name }).map((l) => l.changeset);
+            const deployed = this.deployedOf(all);
+            return Response.json({ changesets: all.map((c, i) => ({ ...c, currentHash: changesetContentHash(c), deployed: deployed[i] })) });
         }
         if (kind === 'changesets' && name && verb === 'verify' && request.method === 'POST') {
             const outcome = await this.serialized('changesets', () => verifyWorldChangeset(name, { root: this.worldRoot, world: this.name, ephemeral: true }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/world-runtime",
-  "version": "2.0.40",
+  "version": "2.0.41",
   "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.22",
+    "@volter/world-core": "2.0.23",
     "@volter/world-console": "2.0.13"
   },
   "dependencies": {
     "@electric-sql/pglite": "0.5.8",
     "@electric-sql/pglite-pgvector": "0.0.9",
     "@volter/world-access": "2.0.2",
-    "@volter/world-core": "2.0.22",
+    "@volter/world-core": "2.0.23",
     "pg-gateway": "0.3.0-beta.4",
     "smol-toml": "^1.8.0"
   },
@@ -84,6 +84,6 @@
     }
   },
   "optionalDependencies": {
-    "@volter/twin-mongodb": "0.1.22"
+    "@volter/twin-mongodb": "0.1.23"
   }
 }

package/src/branch.ts

@@ -69,7 +69,9 @@ export async function branchWorld(base: string, name: string, options: BranchOpt
   }
   const forked: Record<string, string[]> = {};
   try {
-    if (from.origin) { instance.origin = { ...from.origin }; saveWorldInstance(instance); }
+    // the branch's origin is its base's, or none: never one a stopped World of the same name left
+    if (from.origin) instance.origin = { ...from.origin }; else delete instance.origin;
+    saveWorldInstance(instance);
     for (const { service, fromRoot, states } of source) {
       const toRoot = join(instance.dirs.data, service);
       for (const { state, generation, view, position: pos } of states) {

package/src/origin.ts

@@ -9,6 +9,7 @@ import { appendOriginEntry, appendParentEntry, branchEntries, getActiveWorldStor
 import { saveWorldInstance, statusWorld } from './runtime.ts';
 import type { WorldInstance } from './schema.ts';
 import { fetchReady, isPathRemote, localWorld, TOKEN_HEADER } from './served-world.ts';
+import { loadWorldConfig, writeWorldConfig } from './configs.ts';
 
 export type FetchOptions = { root?: string; url?: string; namespace?: string; key: string; full?: boolean; services?: string[]; views?: Record<string, HistoryReference>; now?: Date };
 export type FetchOutcome = {
@@ -126,6 +127,16 @@ export async function fetchFromOrigin(name: string, options: FetchOptions): Prom
 
   }
   saveWorldInstance({ ...instance, origin: { ...origin, ...(options.full ? { clonedAt: at_ } : instance.origin?.clonedAt ? { clonedAt: instance.origin.clonedAt } : {}), fetchedAt: at_ } });
+  // a clone names its remote where `volter remote add` does (world.json, as git config holds a remote): one record of
+  // it, which every restart carries (runtime's namesOrigin) and `remote remove` ends. Only the World the config is
+  // for writes it: a runtime branch boots from its base's config, whose remote stays the base's
+  if (options.full && instance.name === instance.config) {
+    try {
+      const { path: configPath, config } = loadWorldConfig(instance.configPath, root);
+      const named = isPathRemote(origin.url) ? origin.url : `${origin.url}/${origin.namespace}`;
+      if (config.remotes?.origin !== named) writeWorldConfig(configPath, { ...config, remotes: { ...(config.remotes ?? {}), origin: named } });
+    } catch (error) { console.error(`[origin] ${name}: the remote was not named in its config: ${(error as Error).message}`); }
+  }
   return { world: name, origin, full: options.full ?? false, appended, behind, snapshots };
 }
 

package/src/runtime.ts

@@ -757,6 +757,17 @@ function writePidsFromInstance(instance: WorldInstance, fresh: number[] = []): v
   writeOwnedPids(instance.root, instance.name, pids, fresh);
 }
 
+/** Whether a world.json remote (`https://<host>/<org>/<world>`, or a world's directory, relative to the World's root) is
+ *  the recorded origin, read as the CLI's parseOriginUrl reads it (the URL's origin, then its two path parts). */
+function namesOrigin(remote: string | undefined, origin: { url: string; namespace: string }, worldRoot: string): boolean {
+  if (!remote) return false;
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(remote)) return resolve(worldRoot, remote) === resolve(worldRoot, origin.url);
+  try {
+    const parsed = new URL(remote); const parts = parsed.pathname.split('/').filter(Boolean);
+    return parts.length === 2 && parsed.origin === new URL(origin.url).origin && parts.join('/') === origin.namespace;
+  } catch { return false; }
+}
+
 export function saveWorldInstance(instance: WorldInstance): void {
   writeTextAtomic(instanceFile(instance.root, instance.name), `${JSON.stringify(instance, null, 2)}\n`);
 }
@@ -1483,6 +1494,7 @@ export async function upWorld(configId: string, options: UpWorldOptions = {}, ab
   const pidsFile = join(instance, 'pids');
   const envFile = resolve(root, options.envFile ?? join(instance, 'world.env'));
   const instanceFile = join(instance, 'instance.json');
+  let carriedOrigin: WorldInstance['origin'] | undefined;
   const priorOutputInstance = existsSync(instanceFile) ? JSON.parse(readFileSync(instanceFile, 'utf8')) as WorldInstance : undefined;
   const priorOutput = priorOutputInstance?.name === name && resolve(priorOutputInstance.root) === root
     ? { path: resolve(priorOutputInstance.envFile), contents: envFileContents(priorOutputInstance.env) } : undefined;
@@ -1537,6 +1549,14 @@ export async function upWorld(configId: string, options: UpWorldOptions = {}, ab
           || !Number.isFinite(Date.parse(receipt.stoppedAt))) {
           throw new Error(`World "${name}" has no verified teardown receipt for its prior instance; use its owning runtime to complete cleanup before replacement`);
         }
+        // the origin belongs to the World, not to its running state (git: a remote outlives every checkout): an up of the
+        // same config carries the one the last left while world.json's `origin` remote still names it (`remote remove`
+        // ends it there; an instance under another World's config, a runtime branch, has only its own record); its cursors
+        // only when its state (the mirror they count) is kept, as reset drops them
+        if (prior.origin && prior.config === loaded.config.id && (name !== loaded.config.id || namesOrigin(loaded.config.remotes?.origin, prior.origin, root))) {
+          carriedOrigin = options.keepState ? prior.origin
+            : { url: prior.origin.url, namespace: prior.origin.namespace, ...(prior.origin.clonedAt ? { clonedAt: prior.origin.clonedAt } : {}) };
+        }
       }
       assertLifecycleStartable(root, name);
       beginWorldLifecycle(root, name, createdAt, options.owner);
@@ -1622,6 +1642,7 @@ export async function upWorld(configId: string, options: UpWorldOptions = {}, ab
       ...(loaded.config.actors ? { actors: loaded.config.actors } : {}),
       ...(loaded.config.fixtures ? { fixtures: loaded.config.fixtures } : {}),
       lifecycle: { owner: options.owner, log: lifecycleLogPath(root, name) },
+      ...(carriedOrigin ? { origin: carriedOrigin } : {}),
     };
     saveWorldInstance(worldInstance);
     const cancelled = new AbortController();

package/src/served-world.ts

@@ -595,6 +595,32 @@ export class WorldDoors {
     if (grant.via === 'session') return { scope: grant.scope, via: 'session', token: null, session: grant.session!, ...(grant.who ? { who: grant.who } : {}) };
     return { scope: grant.scope, via: grant.via === 'key' ? 'key' : 'token', token: grant.presented ?? null };
   }
+  /** Each changeset's actions' receipts, from the landed copies on each twin's log: a deploy appends one per entry it
+   *  performed, and a push one per entry it landed at the remote (`landed` while the remote waits, beside the
+   *  changeset's own `applied`). */
+  private deployedOf(changesets: Changeset[]): Array<Array<{ service: string; actionId: string } & Receipt>> {
+    // by the state each action was written in (a twin may hold several), and a settled receipt wins over a provisional
+    // `landed` one whichever comes later in the log (a push's local copy, then the remote's deploy fetched in)
+    const landed = new Map<string, Map<string, Receipt>>();
+    const of = (service: string, state: string): Map<string, Receipt> => {
+      const at = `${service}\u0000${state}`;
+      let held = landed.get(at);
+      if (!held) {
+        held = new Map();
+        if (this.up().services[service]) {
+          for (const e of parentEntries(state, this.controlRoot(service))) {
+            if (!e.landsId || !e.receipt) continue;
+            const before = held.get(e.landsId);
+            if (!before || before.status === 'landed' || e.receipt.status !== 'landed') held.set(e.landsId, e.receipt);
+          }
+        }
+        landed.set(at, held);
+      }
+      return held;
+    };
+    return changesets.map((c) => c.actions.flatMap((a) => { const r = of(a.service, a.stateService ?? this.stateOf(a.service)).get(a.action.id); return r ? [{ service: a.service, actionId: a.action.id, ...r }] : []; }));
+  }
+
   /** Who made a request, as this World names it: `key:<name>` for a named key, `person:<who>` for a browser's session
    *  (`person` when it names no one), `token` / `token:read` for the World's own tokens; null when it presented nothing
    *  this World issued. */
@@ -1040,8 +1066,10 @@ export class WorldDoors {
     }
     if (kind === 'changesets' && request.method === 'GET') {
       // with the body's hash as it stands, so a reader sees an approval or a verification made on other bytes as stale
-      if (name) { const l = findWorldChangeset(name, { root: this.worldRoot, world: this.name }); return Response.json({ ...l.changeset, currentHash: changesetContentHash(l.changeset) }); }
-      return Response.json({ changesets: listWorldChangesets({ root: this.worldRoot, world: this.name }).map((l) => ({ ...l.changeset, currentHash: changesetContentHash(l.changeset) })) });
+      if (name) { const l = findWorldChangeset(name, { root: this.worldRoot, world: this.name }); return Response.json({ ...l.changeset, currentHash: changesetContentHash(l.changeset), deployed: this.deployedOf([l.changeset])[0] }); }
+      const all = listWorldChangesets({ root: this.worldRoot, world: this.name }).map((l) => l.changeset);
+      const deployed = this.deployedOf(all);
+      return Response.json({ changesets: all.map((c, i) => ({ ...c, currentHash: changesetContentHash(c), deployed: deployed[i] })) });
     }
     if (kind === 'changesets' && name && verb === 'verify' && request.method === 'POST') {
       const outcome = await this.serialized('changesets', () => verifyWorldChangeset(name, { root: this.worldRoot, world: this.name, ephemeral: true }));