@volter/world-runtime 3.0.59 → 3.0.61

package/dist/src/covers.js

@@ -25,7 +25,7 @@ import { errorMessage } from "./error-message.js";
 import { existsSync, readFileSync } from 'node:fs';
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { vendorOfPackModule } from '@volter/world-core/runtime';
+import { installedPackageDir, packVendor, vendorOfPackModule } from '@volter/world-core/runtime';
 import { loadWorldConfig } from "./configs.js";
 import { VENDOR_SERVER_BACKINGS } from "./backings.js";
 import { injectableVendorKeys, loadInject, twinUrlVendorFor } from "./inject-map.js";
@@ -260,7 +260,7 @@ function serverBacking(service) {
         return undefined;
     return backing;
 }
-function addBackingIds(ids, services, effectiveEnv) {
+function addBackingIds(ids, services, effectiveEnv, root = process.cwd()) {
     for (const service of services) {
         const backing = serverBacking(service);
         if (backing) {
@@ -276,7 +276,7 @@ function addBackingIds(ids, services, effectiveEnv) {
         }
         // A protocol already proved owned by this service can satisfy its declared native driver.
         // HTTP-only siblings of the same vendor retain their independent interface obligations.
-        for (const binding of serviceConnections([service], effectiveEnv).values()) {
+        for (const binding of serviceConnections([service], effectiveEnv, root).values()) {
             for (const [vendor, facts] of Object.entries(packFacts())) {
                 if (facts.transport === 'raw-tcp' && facts.managedService?.scheme === binding.protocol) {
                     addId(ids, normalizeId(vendor), `${binding.label}; managed ${facts.managedService.kind} backing`, true);
@@ -285,18 +285,17 @@ function addBackingIds(ids, services, effectiveEnv) {
         }
     }
 }
-function declaredTwin(services, effectiveEnv) {
+function declaredTwin(services, effectiveEnv, root = process.cwd()) {
     const declared = new Map();
     for (const service of services) {
         if (service.type !== undefined && service.type !== 'twin' && !serverBacking(service))
             continue;
-        const config = service;
-        const identity = config.package?.match(/^@volter\/twin-(.+)$/)?.[1] ?? servicePackNames(config)[0] ?? service.id;
+        const identity = servicePackNames(service, root)[0] ?? service.id;
         const vendor = Object.keys(packFacts()).find((candidate) => worldIdsFor(candidate).includes(normalizeId(identity))) ?? identity;
         const ids = new Map();
         if (!serverBacking(service))
-            addServiceIds(ids, service);
-        addBackingIds(ids, [service], effectiveEnv);
+            addServiceIds(ids, service, root);
+        addBackingIds(ids, [service], effectiveEnv, root);
         const match = [...worldIdsFor(vendor), vendor].map(normalizeId).map((id) => ids.get(id)).find(Boolean);
         declared.set(vendor, match ?? { label: `${service.id} (declared twin)`, interceptable: false });
     }
@@ -311,14 +310,18 @@ function addId(ids, key, label, interceptable) {
     else if (interceptable && !existing.interceptable)
         existing.interceptable = true;
 }
-function servicePackNames(service) {
+function servicePackNames(service, root = process.cwd()) {
+    const installed = service.package && installedPackageDir(root, service.package);
+    const vendor = installed ? packVendor(installed) : undefined;
+    if (vendor)
+        return [vendor];
     const commandParts = [
         ...(service.package ? [service.package] : []),
         ...(Array.isArray(service.command) ? service.command : service.command ? [service.command] : []),
         ...(service.args ?? []),
         ...(service.colocate?.module ? [service.colocate.module] : []),
     ];
-    return commandParts.flatMap((argument, index) => {
+    const parts = commandParts.flatMap((argument, index) => {
         // A shared host command is recorded on each service. Only that service's
         // module identifies its pack; its neighbours' modules must not cover it.
         let part = argument;
@@ -328,23 +331,31 @@ function servicePackNames(service) {
                 return [];
             part = module;
         }
+        return [part];
+    });
+    const vendors = parts.flatMap((part) => {
+        const identity = /\.(?:[cm]?js|tsx?)$/.test(part) ? vendorOfPackModule(resolve(root, part)) : undefined;
+        return identity ? [identity] : [];
+    });
+    if (vendors.length)
+        return [...new Set(vendors)];
+    return parts.flatMap((part) => {
         const fromPath = part.match(/(?:^|[/\\])twin-packs-p[23][/\\]([a-z0-9-]+)[/\\]/);
         const fromBin = part.match(/^world-([a-z0-9-]+)$/);
         const fromPkg = part.match(/(?:^|[/\\])@volter\/twin-([a-z0-9-]+)(?:[/\\]|$)/);
-        const fromManifest = /\.(?:[cm]?js|tsx?)$/.test(part) ? vendorOfPackModule(part) : undefined;
-        return [fromManifest, fromPath?.[1], fromBin?.[1], fromPkg?.[1]].filter((name) => name !== undefined);
+        return [fromPath?.[1], fromBin?.[1], fromPkg?.[1]].filter((name) => name !== undefined);
     });
 }
 /** Endpoint wiring owned by a service, never a random URL from global config/env. Config
  * templates must use the service's allocated host/port. Instance values must point at that
  * listener, or have been discovered by the external lifecycle. HTTP pack facts veto native
  * coverage even when someone has put a mysql:// template on an HTTP twin. */
-function serviceConnections(services, effectiveEnv) {
+function serviceConnections(services, effectiveEnv, root = process.cwd()) {
     const bindings = new Map();
     for (const service of services) {
         const instance = 'pid' in service;
         const config = instance ? undefined : service;
-        const facts = servicePackNames(service).map((name) => packFacts()[name]).filter((fact) => fact !== undefined);
+        const facts = servicePackNames(service, root).map((name) => packFacts()[name]).filter((fact) => fact !== undefined);
         if (!instance && config?.injectEnv)
             bindings.set(config.injectEnv, { protocol: 'http', label: `${service.id} (${config.injectEnv})` });
         const values = instance ? service.env : config?.injectEnvTemplates ?? {};
@@ -392,9 +403,9 @@ function serviceConnections(services, effectiveEnv) {
     }
     return bindings;
 }
-function addServiceIds(ids, service) {
+function addServiceIds(ids, service, root = process.cwd()) {
     const type = service.type ?? 'twin';
-    const packNames = servicePackNames(service);
+    const packNames = servicePackNames(service, root);
     // How would traffic actually reach this twin?
     //   • the injector/ambient proxy intercepts its vendor hosts — true when its injectEnv is a
     //     `*_TWIN_URL` var the injector reads, or its service id / pack name IS an injector
@@ -450,15 +461,15 @@ export function worldTwinInventory(world, root) {
         const ids = new Map();
         for (const service of Object.values(status.services))
             if (!serverBacking(service))
-                addServiceIds(ids, service);
-        addBackingIds(ids, Object.values(status.services), status.env);
+                addServiceIds(ids, service, root);
+        addBackingIds(ids, Object.values(status.services), status.env, root);
         for (const key of Object.keys(status.env)) {
             const stem = key.match(/^(.+)_TWIN_URL$/);
             // a bare env `*_TWIN_URL` var is only a REACHABLE twin when the injector reads it
             if (stem)
                 addId(ids, normalizeId(stem[1]), `env ${key}`, twinUrlVendorFor(key) !== null);
         }
-        return { services: Object.values(status.services), source: 'instance', path: `${status.dirs.instance}/instance.json`, ids, connections: serviceConnections(Object.values(status.services), status.env), selection: status.selection, declared: declaredTwin(Object.values(status.services), status.env) };
+        return { services: Object.values(status.services), source: 'instance', path: `${status.dirs.instance}/instance.json`, ids, connections: serviceConnections(Object.values(status.services), status.env, root), selection: status.selection, declared: declaredTwin(Object.values(status.services), status.env, root) };
     }
     catch (error) {
         instanceError = errorMessage(error);
@@ -468,16 +479,16 @@ export function worldTwinInventory(world, root) {
         const ids = new Map();
         for (const service of config.services)
             if (!serverBacking(service))
-                addServiceIds(ids, service);
-        addBackingIds(ids, config.services);
-        const connections = serviceConnections(config.services);
+                addServiceIds(ids, service, root);
+        addBackingIds(ids, config.services, undefined, root);
+        const connections = serviceConnections(config.services, undefined, root);
         // a name the World's env leaves to a twin's credential door (`$issue:<service>`) is that twin's, whatever scheme the
         // issued value has: the twin that issues it serves it
         for (const [name, value] of Object.entries(config.env ?? {})) {
             if (value.startsWith(ISSUE_ENV_PREFIX))
                 connections.set(name, { protocol: 'issued', label: `${value.slice(ISSUE_ENV_PREFIX.length)} (${name}; issued)` });
         }
-        return { services: config.services, source: 'config', path, ids, connections, selection: config.selection, declared: declaredTwin(config.services) };
+        return { services: config.services, source: 'config', path, ids, connections, selection: config.selection, declared: declaredTwin(config.services, undefined, root) };
     }
     catch (error) {
         const configError = errorMessage(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/world-runtime",
-  "version": "3.0.59",
+  "version": "3.0.61",
   "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",
@@ -69,14 +69,14 @@
     "node": ">=22.3"
   },
   "peerDependencies": {
-    "@volter/world-core": "3.0.59",
-    "@volter/world-console": "3.0.54"
+    "@volter/world-core": "3.0.61",
+    "@volter/world-console": "3.0.56"
   },
   "dependencies": {
     "@electric-sql/pglite": "0.5.8",
     "@electric-sql/pglite-pgvector": "0.0.9",
     "@volter/world-access": "3.0.1",
-    "@volter/world-core": "3.0.59",
+    "@volter/world-core": "3.0.61",
     "mongodb": "~6.20.0",
     "pg-gateway": "0.3.0-beta.4",
     "smol-toml": "^1.8.0",

package/src/covers.ts

@@ -26,7 +26,7 @@ import { errorMessage } from './error-message.ts';
 import { existsSync, readFileSync } from 'node:fs';
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { vendorOfPackModule } from '@volter/world-core/runtime';
+import { installedPackageDir, packVendor, vendorOfPackModule } from '@volter/world-core/runtime';
 import { loadWorldConfig } from './configs.ts';
 import { VENDOR_SERVER_BACKINGS } from './backings.ts';
 import { injectableVendorKeys, loadInject, twinUrlVendorFor } from './inject-map.ts';
@@ -367,6 +367,7 @@ function addBackingIds(
   ids: Map<string, WorldTwinId>,
   services: Array<WorldServiceConfig | WorldServiceInstance>,
   effectiveEnv?: Record<string, string>,
+  root = process.cwd(),
 ): void {
   for (const service of services) {
     const backing = serverBacking(service);
@@ -383,7 +384,7 @@ function addBackingIds(
     }
     // A protocol already proved owned by this service can satisfy its declared native driver.
     // HTTP-only siblings of the same vendor retain their independent interface obligations.
-    for (const binding of serviceConnections([service], effectiveEnv).values()) {
+    for (const binding of serviceConnections([service], effectiveEnv, root).values()) {
       for (const [vendor, facts] of Object.entries(packFacts())) {
         if (facts.transport === 'raw-tcp' && facts.managedService?.scheme === binding.protocol) {
           addId(ids, normalizeId(vendor), `${binding.label}; managed ${facts.managedService.kind} backing`, true);
@@ -393,16 +394,15 @@ function addBackingIds(
   }
 }
 
-function declaredTwin(services: Array<WorldServiceConfig | WorldServiceInstance>, effectiveEnv?: Record<string, string>): Map<string, WorldTwinId> {
+function declaredTwin(services: Array<WorldServiceConfig | WorldServiceInstance>, effectiveEnv?: Record<string, string>, root = process.cwd()): Map<string, WorldTwinId> {
   const declared = new Map<string, WorldTwinId>();
   for (const service of services) {
     if (service.type !== undefined && service.type !== 'twin' && !serverBacking(service)) continue;
-    const config = service as WorldServiceConfig;
-    const identity = config.package?.match(/^@volter\/twin-(.+)$/)?.[1] ?? servicePackNames(config)[0] ?? service.id;
+    const identity = servicePackNames(service, root)[0] ?? service.id;
     const vendor = Object.keys(packFacts()).find((candidate) => worldIdsFor(candidate).includes(normalizeId(identity))) ?? identity;
     const ids = new Map<string, WorldTwinId>();
-    if (!serverBacking(service)) addServiceIds(ids, service);
-    addBackingIds(ids, [service], effectiveEnv);
+    if (!serverBacking(service)) addServiceIds(ids, service, root);
+    addBackingIds(ids, [service], effectiveEnv, root);
     const match = [...worldIdsFor(vendor), vendor].map(normalizeId).map((id) => ids.get(id)).find(Boolean);
     declared.set(vendor, match ?? { label: `${service.id} (declared twin)`, interceptable: false });
   }
@@ -417,14 +417,17 @@ function addId(ids: Map<string, WorldTwinId>, key: string, label: string, interc
   else if (interceptable && !existing.interceptable) existing.interceptable = true;
 }
 
-function servicePackNames(service: { id?: string; package?: string; command?: string | string[]; args?: string[]; colocate?: { module?: string } }): string[] {
+function servicePackNames(service: { id?: string; package?: string; command?: string | string[]; args?: string[]; colocate?: { module?: string } }, root = process.cwd()): string[] {
+  const installed = service.package && installedPackageDir(root, service.package);
+  const vendor = installed ? packVendor(installed) : undefined;
+  if (vendor) return [vendor];
   const commandParts = [
     ...(service.package ? [service.package] : []),
     ...(Array.isArray(service.command) ? service.command : service.command ? [service.command] : []),
     ...(service.args ?? []),
     ...(service.colocate?.module ? [service.colocate.module] : []),
   ];
-  return commandParts.flatMap((argument, index) => {
+  const parts = commandParts.flatMap((argument, index) => {
     // A shared host command is recorded on each service. Only that service's
     // module identifies its pack; its neighbours' modules must not cover it.
     let part = argument;
@@ -433,11 +436,18 @@ function servicePackNames(service: { id?: string; package?: string; command?: st
       if (id !== service.id || !module) return [];
       part = module;
     }
+    return [part];
+  });
+  const vendors = parts.flatMap((part) => {
+    const identity = /\.(?:[cm]?js|tsx?)$/.test(part) ? vendorOfPackModule(resolve(root, part)) : undefined;
+    return identity ? [identity] : [];
+  });
+  if (vendors.length) return [...new Set(vendors)];
+  return parts.flatMap((part) => {
     const fromPath = part.match(/(?:^|[/\\])twin-packs-p[23][/\\]([a-z0-9-]+)[/\\]/);
     const fromBin = part.match(/^world-([a-z0-9-]+)$/);
     const fromPkg = part.match(/(?:^|[/\\])@volter\/twin-([a-z0-9-]+)(?:[/\\]|$)/);
-    const fromManifest = /\.(?:[cm]?js|tsx?)$/.test(part) ? vendorOfPackModule(part) : undefined;
-    return [fromManifest, fromPath?.[1], fromBin?.[1], fromPkg?.[1]].filter((name): name is string => name !== undefined);
+    return [fromPath?.[1], fromBin?.[1], fromPkg?.[1]].filter((name): name is string => name !== undefined);
   });
 }
 
@@ -448,12 +458,13 @@ function servicePackNames(service: { id?: string; package?: string; command?: st
 function serviceConnections(
   services: Array<WorldServiceConfig | WorldServiceInstance>,
   effectiveEnv?: Record<string, string>,
+  root = process.cwd(),
 ): WorldTwinInventory['connections'] {
   const bindings: WorldTwinInventory['connections'] = new Map();
   for (const service of services) {
     const instance = 'pid' in service;
     const config = instance ? undefined : service;
-    const facts = servicePackNames(service).map((name) => packFacts()[name]).filter((fact) => fact !== undefined);
+    const facts = servicePackNames(service, root).map((name) => packFacts()[name]).filter((fact) => fact !== undefined);
     if (!instance && config?.injectEnv) bindings.set(config.injectEnv, { protocol: 'http', label: `${service.id} (${config.injectEnv})` });
     const values = instance ? service.env : config?.injectEnvTemplates ?? {};
     for (const [name, value] of Object.entries(values)) {
@@ -512,9 +523,10 @@ function addServiceIds(
     package?: string;
     colocate?: { module?: string };
   },
+  root = process.cwd(),
 ): void {
   const type = service.type ?? 'twin';
-  const packNames = servicePackNames(service);
+  const packNames = servicePackNames(service, root);
   // How would traffic actually reach this twin?
   //   • the injector/ambient proxy intercepts its vendor hosts — true when its injectEnv is a
   //     `*_TWIN_URL` var the injector reads, or its service id / pack name IS an injector
@@ -571,29 +583,29 @@ export function worldTwinInventory(world: string, root: string): WorldTwinInvent
   try {
     const status = statusWorld(world, root, { readOnly: true });
     const ids = new Map<string, WorldTwinId>();
-    for (const service of Object.values(status.services)) if (!serverBacking(service)) addServiceIds(ids, service);
-    addBackingIds(ids, Object.values(status.services), status.env);
+    for (const service of Object.values(status.services)) if (!serverBacking(service)) addServiceIds(ids, service, root);
+    addBackingIds(ids, Object.values(status.services), status.env, root);
     for (const key of Object.keys(status.env)) {
       const stem = key.match(/^(.+)_TWIN_URL$/);
       // a bare env `*_TWIN_URL` var is only a REACHABLE twin when the injector reads it
       if (stem) addId(ids, normalizeId(stem[1]!), `env ${key}`, twinUrlVendorFor(key) !== null);
     }
-    return { services: Object.values(status.services), source: 'instance', path: `${status.dirs.instance}/instance.json`, ids, connections: serviceConnections(Object.values(status.services), status.env), selection: status.selection, declared: declaredTwin(Object.values(status.services), status.env) };
+    return { services: Object.values(status.services), source: 'instance', path: `${status.dirs.instance}/instance.json`, ids, connections: serviceConnections(Object.values(status.services), status.env, root), selection: status.selection, declared: declaredTwin(Object.values(status.services), status.env, root) };
   } catch (error) {
     instanceError = errorMessage(error);
   }
   try {
     const { path, config } = loadWorldConfig(world, root);
     const ids = new Map<string, WorldTwinId>();
-    for (const service of config.services as WorldServiceConfig[]) if (!serverBacking(service)) addServiceIds(ids, service);
-    addBackingIds(ids, config.services);
-    const connections = serviceConnections(config.services);
+    for (const service of config.services as WorldServiceConfig[]) if (!serverBacking(service)) addServiceIds(ids, service, root);
+    addBackingIds(ids, config.services, undefined, root);
+    const connections = serviceConnections(config.services, undefined, root);
     // a name the World's env leaves to a twin's credential door (`$issue:<service>`) is that twin's, whatever scheme the
     // issued value has: the twin that issues it serves it
     for (const [name, value] of Object.entries(config.env ?? {})) {
       if (value.startsWith(ISSUE_ENV_PREFIX)) connections.set(name, { protocol: 'issued', label: `${value.slice(ISSUE_ENV_PREFIX.length)} (${name}; issued)` });
     }
-    return { services: config.services, source: 'config', path, ids, connections, selection: config.selection, declared: declaredTwin(config.services) };
+    return { services: config.services, source: 'config', path, ids, connections, selection: config.selection, declared: declaredTwin(config.services, undefined, root) };
   } catch (error) {
     const configError = errorMessage(error);
     throw new Error(