@volter/world-core 2.0.0 → 2.0.1

package/app-route.cjs

@@ -116,13 +116,17 @@ function appRequestOptions(route, url, method, headers, extra) {
 /** One request to the application for `value`, a URL on one of its hosts, as `route` (appDestination's answer) names
  *  it, with appRequestOptions' headers. No redirect is followed: the caller decides, as a delivery reports what it got.
  *  Answers { status, headers (lower-cased), body (decoded text) } within `timeoutMs` overall; a failure rejects. */
-function deliverToApp(route, value, { method = 'POST', headers = {}, body, timeoutMs = 30_000 } = {}) {
+function deliverToApp(route, value, { method = 'POST', headers = {}, body, timeoutMs = 30_000, signal } = {}) {
   const url = new URL(String(value));
+  if (signal && signal.aborted) return Promise.reject(signal.reason);
   const options = appRequestOptions(route, url, method, headers);
   const make = (options.protocol === 'https:' ? require('https') : require('http')).request;
   return new Promise((resolve, reject) => {
     let settled = false;
-    const fail = (error) => { if (!settled) { settled = true; clearTimeout(deadline); req.destroy(); reject(error); } };
+    // an abort (the caller's `signal`, as fetch's) ends the exchange with the signal's reason
+    const onAbort = () => fail(signal.reason);
+    const done = () => { settled = true; clearTimeout(deadline); if (signal) signal.removeEventListener('abort', onAbort); };
+    const fail = (error) => { if (!settled) { done(); req.destroy(); reject(error); } };
     const req = make(options, (res) => {
       // a reply cut off mid-body fails the delivery, decoded or not (pipe forwards no error to the decoder)
       res.on('error', fail);
@@ -136,19 +140,104 @@ function deliverToApp(route, value, { method = 'POST', headers = {}, body, timeo
       stream.on('error', fail);
       stream.on('end', () => {
         if (settled) return;
-        settled = true;
-        clearTimeout(deadline);
+        done();
         const answer = {};
         for (const [k, v] of Object.entries(res.headers)) if (v !== undefined && !(decoder && (k === 'content-encoding' || k === 'content-length'))) answer[k.toLowerCase()] = Array.isArray(v) ? v.join(', ') : String(v);
         resolve({ status: res.statusCode, headers: answer, body: Buffer.concat(chunks).toString('utf8') });
       });
     });
     // one deadline for the whole exchange, not an idle timeout: an answer that trickles is still cut off
-    const deadline = setTimeout(() => fail(new Error(`the application did not answer ${url.origin}${url.pathname} within ${timeoutMs} ms`)), timeoutMs);
+    // (Infinity: none, the caller's signal governing, as fetch has no overall deadline)
+    const deadline = Number.isFinite(timeoutMs) ? setTimeout(() => fail(new Error(`the application did not answer ${url.origin}${url.pathname} within ${timeoutMs} ms`)), timeoutMs) : undefined;
     req.on('error', fail);
+    if (signal) signal.addEventListener('abort', onAbort, { once: true });
     if (body != null && method !== 'GET' && method !== 'HEAD') req.write(body);
     req.end();
   });
 }
 
-module.exports = { appRoute, appHostMatch, appForwardHeaders, appDestination, appRequestOptions, deliverToApp, sessionCa };
+const REDIRECTS = [301, 302, 303, 307, 308];
+const NULL_BODY = [204, 205, 304];
+// what fetch drops from a request when a redirect crosses origins
+const CROSS_ORIGIN_DROPPED = ['authorization', 'cookie', 'proxy-authorization'];
+
+/** A request body as fetch takes one, as the bytes deliverToApp sends (a form's default content type set, as fetch sets it). */
+function requestBody(body, headers) {
+  if (body == null) return null;
+  if (typeof body === 'string') return body;
+  if (body instanceof URLSearchParams) {
+    if (!Object.keys(headers).some((k) => k.toLowerCase() === 'content-type')) headers['content-type'] = 'application/x-www-form-urlencoded;charset=UTF-8';
+    return body.toString();
+  }
+  if (body instanceof ArrayBuffer) return Buffer.from(body);
+  if (ArrayBuffer.isView(body)) return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+  throw new TypeError('appFetch sends a string, URLSearchParams or bytes body');
+}
+
+/** fetch, as a twin's own outbound delivery makes it from the colocated twin host (which runs without the injector):
+ *  a URL on one of the application's hostnames (appDestination) reaches the application where it listens
+ *  (deliverToApp), any other URL is fetch's own request. The caller applies worldEgressRefusal to the URL first when
+ *  appDestination names no application for it, as before, and appFetch applies it again (a refusal rejects), so a
+ *  host that left the record between the two is never let out ungated; the answer is a Response, read as fetch's is.
+ *  From the application, `init.redirect` is honoured as fetch honours it: 'follow' (the default) follows at most 20, a
+ *  303, or a 301/302 after a POST, becoming a GET without its body, and drops the credentials crossing origins;
+ *  'manual' answers the 3xx itself; 'error' rejects. Every hop is routed again: onto the application's hosts it
+ *  reaches the application, elsewhere it goes out only where worldEgressRefusal lets it (a refusal rejects as an
+ *  unreachable host does). `init.signal` aborts, as fetch's does. */
+async function appFetch(value, init = {}) {
+  // the route is read again here, so a host no longer recorded since the caller asked is gated as any other URL
+  if (!appDestination(value)) {
+    const refusal = require('./network-policy.cjs').worldEgressRefusal(value);
+    if (refusal !== null) throw new TypeError(refusal);
+    return fetch(value, init);
+  }
+  const mode = init.redirect || 'follow';
+  const signal = init.signal || undefined;
+  let at = new URL(String(value));
+  let method = String(init.method || 'GET').toUpperCase();
+  const headers = {};
+  new Headers(init.headers || {}).forEach((v, k) => { headers[k] = v; });
+  let body = requestBody(init.body, headers);
+  for (let hops = 0; ; hops++) {
+    const route = appDestination(at);
+    let res;
+    if (route) {
+      // the application's own origin is where the request goes: an application recorded outside the World (an app-url
+      // naming a deployment elsewhere) meets the World's egress rule as any other destination does
+      const originRefusal = require('./network-policy.cjs').worldEgressRefusal(route.origin);
+      if (originRefusal !== null) throw new TypeError(originRefusal);
+      // fetch's own bound (undici's 300 s headers and body timeouts), whatever signal the caller gives, so a hung
+      // application never holds a delivery, or the API request awaiting it, for good; a caller's signal may end it sooner
+      const answer = await deliverToApp(route, at, { method, headers, body, signal, timeoutMs: 300_000 });
+      const nullBody = NULL_BODY.includes(answer.status) || method === 'HEAD';
+      // a status fetch resolves with but Response refuses to construct (outside 200-599) is carried as fetch carries it
+      const inRange = answer.status >= 200 && answer.status <= 599;
+      res = new Response(nullBody ? null : answer.body, { status: inRange ? answer.status : 200, headers: answer.headers });
+      if (!inRange) Object.defineProperties(res, { status: { value: answer.status }, ok: { value: false } });
+      Object.defineProperty(res, 'url', { value: at.toString() });
+    } else {
+      const refusal = require('./network-policy.cjs').worldEgressRefusal(at);
+      if (refusal !== null) throw new TypeError(refusal);
+      // off the application, the World's own headers never go with the request
+      for (const k of Object.keys(headers)) if (['x-twins-key', 'x-volter-twin-original-host'].includes(k.toLowerCase())) delete headers[k];
+      res = await fetch(at, { method, headers, ...(body != null && method !== 'GET' && method !== 'HEAD' ? { body } : {}), redirect: 'manual', signal });
+    }
+    if (hops > 0) Object.defineProperty(res, 'redirected', { value: true });
+    const location = res.headers.get('location');
+    if (!REDIRECTS.includes(res.status) || location === null || mode === 'manual') return res;
+    if (mode === 'error') throw new TypeError(`${at.origin}${at.pathname} redirected, and the request's redirect mode is error`);
+    if (hops >= 20) throw new TypeError('redirect count exceeded');
+    if (res.body) await res.body.cancel();
+    const next = new URL(location, at);
+    if (next.protocol !== 'http:' && next.protocol !== 'https:') throw new TypeError(`redirect to ${next.protocol} is not followed`);
+    if ((res.status === 303 && method !== 'GET' && method !== 'HEAD') || ((res.status === 301 || res.status === 302) && method === 'POST')) {
+      method = 'GET';
+      body = null;
+      for (const k of Object.keys(headers)) if (/^content-/i.test(k)) delete headers[k];
+    }
+    if (next.origin !== at.origin) for (const k of Object.keys(headers)) if (CROSS_ORIGIN_DROPPED.includes(k.toLowerCase())) delete headers[k];
+    at = next;
+  }
+}
+
+module.exports = { appRoute, appHostMatch, appForwardHeaders, appDestination, appRequestOptions, deliverToApp, appFetch, sessionCa };

package/app-route.d.cts

@@ -4,4 +4,5 @@ export function appRoute(instanceFile: string | undefined): AppRoute | null;
 export function appHostMatch(hosts: ReadonlySet<string>, host: string): boolean;
 export function appForwardHeaders(url: URL): Record<string, string>;
 export function appDestination(value: string | URL, env?: Readonly<Record<string, string | undefined>>): AppRoute | null;
-export function deliverToApp(route: AppRoute, value: string | URL, init?: { method?: string; headers?: Record<string, string>; body?: string | Uint8Array | null; timeoutMs?: number }): Promise<AppAnswer>;
+export function deliverToApp(route: AppRoute, value: string | URL, init?: { method?: string; headers?: Record<string, string>; body?: string | Uint8Array | null; /** Infinity: no deadline of its own */ timeoutMs?: number; signal?: AbortSignal }): Promise<AppAnswer>;
+export function appFetch(value: string | URL, init?: RequestInit): Promise<Response>;

package/dist/app-route.cjs

@@ -116,13 +116,17 @@ function appRequestOptions(route, url, method, headers, extra) {
 /** One request to the application for `value`, a URL on one of its hosts, as `route` (appDestination's answer) names
  *  it, with appRequestOptions' headers. No redirect is followed: the caller decides, as a delivery reports what it got.
  *  Answers { status, headers (lower-cased), body (decoded text) } within `timeoutMs` overall; a failure rejects. */
-function deliverToApp(route, value, { method = 'POST', headers = {}, body, timeoutMs = 30_000 } = {}) {
+function deliverToApp(route, value, { method = 'POST', headers = {}, body, timeoutMs = 30_000, signal } = {}) {
   const url = new URL(String(value));
+  if (signal && signal.aborted) return Promise.reject(signal.reason);
   const options = appRequestOptions(route, url, method, headers);
   const make = (options.protocol === 'https:' ? require('https') : require('http')).request;
   return new Promise((resolve, reject) => {
     let settled = false;
-    const fail = (error) => { if (!settled) { settled = true; clearTimeout(deadline); req.destroy(); reject(error); } };
+    // an abort (the caller's `signal`, as fetch's) ends the exchange with the signal's reason
+    const onAbort = () => fail(signal.reason);
+    const done = () => { settled = true; clearTimeout(deadline); if (signal) signal.removeEventListener('abort', onAbort); };
+    const fail = (error) => { if (!settled) { done(); req.destroy(); reject(error); } };
     const req = make(options, (res) => {
       // a reply cut off mid-body fails the delivery, decoded or not (pipe forwards no error to the decoder)
       res.on('error', fail);
@@ -136,19 +140,104 @@ function deliverToApp(route, value, { method = 'POST', headers = {}, body, timeo
       stream.on('error', fail);
       stream.on('end', () => {
         if (settled) return;
-        settled = true;
-        clearTimeout(deadline);
+        done();
         const answer = {};
         for (const [k, v] of Object.entries(res.headers)) if (v !== undefined && !(decoder && (k === 'content-encoding' || k === 'content-length'))) answer[k.toLowerCase()] = Array.isArray(v) ? v.join(', ') : String(v);
         resolve({ status: res.statusCode, headers: answer, body: Buffer.concat(chunks).toString('utf8') });
       });
     });
     // one deadline for the whole exchange, not an idle timeout: an answer that trickles is still cut off
-    const deadline = setTimeout(() => fail(new Error(`the application did not answer ${url.origin}${url.pathname} within ${timeoutMs} ms`)), timeoutMs);
+    // (Infinity: none, the caller's signal governing, as fetch has no overall deadline)
+    const deadline = Number.isFinite(timeoutMs) ? setTimeout(() => fail(new Error(`the application did not answer ${url.origin}${url.pathname} within ${timeoutMs} ms`)), timeoutMs) : undefined;
     req.on('error', fail);
+    if (signal) signal.addEventListener('abort', onAbort, { once: true });
     if (body != null && method !== 'GET' && method !== 'HEAD') req.write(body);
     req.end();
   });
 }
 
-module.exports = { appRoute, appHostMatch, appForwardHeaders, appDestination, appRequestOptions, deliverToApp, sessionCa };
+const REDIRECTS = [301, 302, 303, 307, 308];
+const NULL_BODY = [204, 205, 304];
+// what fetch drops from a request when a redirect crosses origins
+const CROSS_ORIGIN_DROPPED = ['authorization', 'cookie', 'proxy-authorization'];
+
+/** A request body as fetch takes one, as the bytes deliverToApp sends (a form's default content type set, as fetch sets it). */
+function requestBody(body, headers) {
+  if (body == null) return null;
+  if (typeof body === 'string') return body;
+  if (body instanceof URLSearchParams) {
+    if (!Object.keys(headers).some((k) => k.toLowerCase() === 'content-type')) headers['content-type'] = 'application/x-www-form-urlencoded;charset=UTF-8';
+    return body.toString();
+  }
+  if (body instanceof ArrayBuffer) return Buffer.from(body);
+  if (ArrayBuffer.isView(body)) return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+  throw new TypeError('appFetch sends a string, URLSearchParams or bytes body');
+}
+
+/** fetch, as a twin's own outbound delivery makes it from the colocated twin host (which runs without the injector):
+ *  a URL on one of the application's hostnames (appDestination) reaches the application where it listens
+ *  (deliverToApp), any other URL is fetch's own request. The caller applies worldEgressRefusal to the URL first when
+ *  appDestination names no application for it, as before, and appFetch applies it again (a refusal rejects), so a
+ *  host that left the record between the two is never let out ungated; the answer is a Response, read as fetch's is.
+ *  From the application, `init.redirect` is honoured as fetch honours it: 'follow' (the default) follows at most 20, a
+ *  303, or a 301/302 after a POST, becoming a GET without its body, and drops the credentials crossing origins;
+ *  'manual' answers the 3xx itself; 'error' rejects. Every hop is routed again: onto the application's hosts it
+ *  reaches the application, elsewhere it goes out only where worldEgressRefusal lets it (a refusal rejects as an
+ *  unreachable host does). `init.signal` aborts, as fetch's does. */
+async function appFetch(value, init = {}) {
+  // the route is read again here, so a host no longer recorded since the caller asked is gated as any other URL
+  if (!appDestination(value)) {
+    const refusal = require('./network-policy.cjs').worldEgressRefusal(value);
+    if (refusal !== null) throw new TypeError(refusal);
+    return fetch(value, init);
+  }
+  const mode = init.redirect || 'follow';
+  const signal = init.signal || undefined;
+  let at = new URL(String(value));
+  let method = String(init.method || 'GET').toUpperCase();
+  const headers = {};
+  new Headers(init.headers || {}).forEach((v, k) => { headers[k] = v; });
+  let body = requestBody(init.body, headers);
+  for (let hops = 0; ; hops++) {
+    const route = appDestination(at);
+    let res;
+    if (route) {
+      // the application's own origin is where the request goes: an application recorded outside the World (an app-url
+      // naming a deployment elsewhere) meets the World's egress rule as any other destination does
+      const originRefusal = require('./network-policy.cjs').worldEgressRefusal(route.origin);
+      if (originRefusal !== null) throw new TypeError(originRefusal);
+      // fetch's own bound (undici's 300 s headers and body timeouts), whatever signal the caller gives, so a hung
+      // application never holds a delivery, or the API request awaiting it, for good; a caller's signal may end it sooner
+      const answer = await deliverToApp(route, at, { method, headers, body, signal, timeoutMs: 300_000 });
+      const nullBody = NULL_BODY.includes(answer.status) || method === 'HEAD';
+      // a status fetch resolves with but Response refuses to construct (outside 200-599) is carried as fetch carries it
+      const inRange = answer.status >= 200 && answer.status <= 599;
+      res = new Response(nullBody ? null : answer.body, { status: inRange ? answer.status : 200, headers: answer.headers });
+      if (!inRange) Object.defineProperties(res, { status: { value: answer.status }, ok: { value: false } });
+      Object.defineProperty(res, 'url', { value: at.toString() });
+    } else {
+      const refusal = require('./network-policy.cjs').worldEgressRefusal(at);
+      if (refusal !== null) throw new TypeError(refusal);
+      // off the application, the World's own headers never go with the request
+      for (const k of Object.keys(headers)) if (['x-twins-key', 'x-volter-twin-original-host'].includes(k.toLowerCase())) delete headers[k];
+      res = await fetch(at, { method, headers, ...(body != null && method !== 'GET' && method !== 'HEAD' ? { body } : {}), redirect: 'manual', signal });
+    }
+    if (hops > 0) Object.defineProperty(res, 'redirected', { value: true });
+    const location = res.headers.get('location');
+    if (!REDIRECTS.includes(res.status) || location === null || mode === 'manual') return res;
+    if (mode === 'error') throw new TypeError(`${at.origin}${at.pathname} redirected, and the request's redirect mode is error`);
+    if (hops >= 20) throw new TypeError('redirect count exceeded');
+    if (res.body) await res.body.cancel();
+    const next = new URL(location, at);
+    if (next.protocol !== 'http:' && next.protocol !== 'https:') throw new TypeError(`redirect to ${next.protocol} is not followed`);
+    if ((res.status === 303 && method !== 'GET' && method !== 'HEAD') || ((res.status === 301 || res.status === 302) && method === 'POST')) {
+      method = 'GET';
+      body = null;
+      for (const k of Object.keys(headers)) if (/^content-/i.test(k)) delete headers[k];
+    }
+    if (next.origin !== at.origin) for (const k of Object.keys(headers)) if (CROSS_ORIGIN_DROPPED.includes(k.toLowerCase())) delete headers[k];
+    at = next;
+  }
+}
+
+module.exports = { appRoute, appHostMatch, appForwardHeaders, appDestination, appRequestOptions, deliverToApp, appFetch, sessionCa };

package/dist/app-route.d.cts

@@ -4,4 +4,5 @@ export function appRoute(instanceFile: string | undefined): AppRoute | null;
 export function appHostMatch(hosts: ReadonlySet<string>, host: string): boolean;
 export function appForwardHeaders(url: URL): Record<string, string>;
 export function appDestination(value: string | URL, env?: Readonly<Record<string, string | undefined>>): AppRoute | null;
-export function deliverToApp(route: AppRoute, value: string | URL, init?: { method?: string; headers?: Record<string, string>; body?: string | Uint8Array | null; timeoutMs?: number }): Promise<AppAnswer>;
+export function deliverToApp(route: AppRoute, value: string | URL, init?: { method?: string; headers?: Record<string, string>; body?: string | Uint8Array | null; /** Infinity: no deadline of its own */ timeoutMs?: number; signal?: AbortSignal }): Promise<AppAnswer>;
+export function appFetch(value: string | URL, init?: RequestInit): Promise<Response>;

package/dist/generated/pack-facts.json

@@ -714,6 +714,9 @@
       "hosts": [
         {
           "host": "api.cohere.com"
+        },
+        {
+          "host": "api.cohere.ai"
         }
       ],
       "archetype": "generative",
@@ -728,7 +731,7 @@
         "embed_job",
         "token"
       ],
-      "endpointEnvNone": "neither official SDK reads a base-URL env var: cohere-ai@8.1.0 takes the override as the `baseUrl`/`environment` CONSTRUCTOR option and reads only CO_API_KEY from the environment (auth/BearerAuthProvider.js), and @ai-sdk/cohere@4.0.35 takes `options.baseURL` and reads only COHERE_API_KEY. Interception is host-based on api.cohere.com; inventing a COHERE_BASE_URL nothing reads would make `covers` claim a world it does not cover.",
+      "endpointEnvNone": "neither official SDK reads a base-URL env var: cohere-ai@8.1.0 takes the override as the `baseUrl`/`environment` CONSTRUCTOR option and reads only CO_API_KEY from the environment (auth/BearerAuthProvider.js), and @ai-sdk/cohere@4.0.35 takes `options.baseURL` and reads only COHERE_API_KEY. Interception is host-based on api.cohere.com and api.cohere.ai; inventing a COHERE_BASE_URL nothing reads would make `covers` claim a world it does not cover.",
       "serveExport": "createCohereTwinServer"
     },
     "currencyapi": {
@@ -963,6 +966,10 @@
           "host": "discord.com",
           "pathPattern": "^/api/"
         },
+        {
+          "host": "discord.com",
+          "pathPattern": "^/(oauth2/authorize|login)/?$"
+        },
         {
           "host": "gateway.discord.gg"
         },
@@ -1399,6 +1406,10 @@
           "host": "github.com",
           "pathPattern": "^/login/oauth/(authorize|access_token)$"
         },
+        {
+          "host": "github.com",
+          "pathPattern": "^/(login|session|sessions/two-factor(/app)?)$"
+        },
         {
           "host": "github.com",
           "pathPattern": "^/apps/[^/]+/installations/new$"
@@ -1470,6 +1481,37 @@
       "endpointEnvNone": "no Google Ads client exposes an HTTP base-URL override: google-ads-api builds the host into the request literally, google-ads-python's `endpoint` is a gRPC host:port for its transport channel, and Dub hardcodes the host in a raw fetch. Interception is host-based.",
       "serveExport": "createGoogleAdsTwinServer"
     },
+    "googlecalendar": {
+      "adoption": {
+        "sdks": [
+          "@googleapis/calendar"
+        ],
+        "pypi": [],
+        "envStems": [
+          "GOOGLECALENDAR"
+        ]
+      },
+      "hosts": [
+        {
+          "host": "www.googleapis.com",
+          "pathPattern": "^/(batch/)?calendar/v3(/|$)"
+        }
+      ],
+      "archetype": "crud",
+      "protocol": {
+        "declared": "2",
+        "major": 2,
+        "standing": "current"
+      },
+      "transport": "rest",
+      "resources": [
+        "Calendar",
+        "CalendarListEntry",
+        "Event"
+      ],
+      "endpointEnvNone": "@googleapis/calendar and googleapis read no base-URL variable: the root URL is the Discovery document's `https://www.googleapis.com/` unless the caller passes `rootUrl` (Inbox Zero reads its own GOOGLE_BASE_URL for that); interception is the host rule above.",
+      "serveExport": "createGooglecalendarTwinServer"
+    },
     "googlemaps": {
       "adoption": {
         "pypi": [
@@ -2148,6 +2190,27 @@
       ],
       "serveExport": "createMixpanelTwinServer"
     },
+    "mongodb": {
+      "adoption": {
+        "pypi": [],
+        "sdks": []
+      },
+      "hostsNone": "RAW-PROTOCOL pack — there is no host to map. MongoDB clients speak the wire protocol over a raw TCP socket to whatever host the connection string names, which the injector (http/fetch patching) cannot see; a World reaches this twin through the connection string itself (MONGO_URI and its kin), which World-managed infrastructure injects.",
+      "archetype": "crud",
+      "protocol": {
+        "declared": "2",
+        "major": 2,
+        "standing": "current"
+      },
+      "transport": "raw-tcp",
+      "resources": [
+        "collection",
+        "index",
+        "document"
+      ],
+      "endpointEnvNone": "no vendor base-URL variable: the application reads its own connection-string variable (MONGO_URI, MONGODB_URL, DATABASE_URL, …), and World-managed infrastructure (`volter-world init` → `volter-world-infra`) injects that variable pointing at this twin's listener.",
+      "serveExport": "createMongodbTwinServer"
+    },
     "moonshot": {
       "adoption": {
         "pypi": [],
@@ -2816,6 +2879,26 @@
       "endpointEnvNone": "reddit clients take no base-URL environment variable (snoowrap and PRAW build https://oauth.reddit.com and https://www.reddit.com URLs from constants or explicit constructor options), so a World reaches them through the hosts above; inventing a REDDIT_BASE_URL the app never reads would report coverage the app does not have.",
       "serveExport": "createRedditTwinServer"
     },
+    "redis": {
+      "adoption": {},
+      "hostsNone": "RAW-PROTOCOL pack — there is no host to map. Redis's protocol runs over a TCP socket the injector (which patches http/fetch) never sees, and a Redis has no vendor hostname: it is wherever the app's REDIS_URL points. The World points it here: init classifies REDIS_URL as managed infrastructure and the managed redis service is this twin.",
+      "archetype": "crud",
+      "protocol": {
+        "major": 1,
+        "standing": "deprecated"
+      },
+      "transport": "raw-tcp",
+      "resources": [
+        "key",
+        "field",
+        "member",
+        "scored",
+        "entry",
+        "script"
+      ],
+      "endpointEnvNone": "Redis clients read no base-URL env of their own: the app passes its REDIS_URL (or host/port) to ioredis or node-redis itself, and init emits that REDIS_URL for the managed redis service (world-runtime/src/init.ts), not as a twin endpoint env.",
+      "serveExport": "createRedisTwinServer"
+    },
     "replicate": {
       "adoption": {
         "pypi": [
@@ -3358,11 +3441,11 @@
         },
         {
           "host": "connect.stripe.com",
-          "pathPattern": "^/setup/"
+          "pathPattern": "^/setup/|^/oauth/(authorize|token|deauthorize)/?$"
         },
         {
           "host": "dashboard.stripe.com",
-          "pathPattern": "^/settings/public/?$"
+          "pathPattern": "^/settings/public/?$|^/(test/)?settings/connect(/onboarding-options/oauth)?/?$"
         },
         {
           "host": "verify.stripe.com",
@@ -3561,6 +3644,38 @@
       "endpointEnvNone": "the @tavily/core SDK exposes no base-URL env var — it reads only TAVILY_API_KEY/TAVILY_HTTP(S)_PROXY/TAVILY_ORG_ID/TAVILY_PROJECT from process.env; base-URL override is the constructor option apiBaseURL (dist/index.mjs post()/get(): `apiBaseURL || BASE_URL`), so interception is the hosts entry above.",
       "serveExport": "createTavilyTwinServer"
     },
+    "temporal": {
+      "adoption": {
+        "sdks": [
+          "@temporalio/client",
+          "@temporalio/worker",
+          "@temporalio/workflow",
+          "@temporalio/activity"
+        ],
+        "scopes": [
+          "@temporalio/"
+        ],
+        "pypi": [
+          "temporalio"
+        ],
+        "envStems": [
+          "TEMPORAL"
+        ]
+      },
+      "hostsNone": "RAW-PROTOCOL pack — there is no host to map. The Temporal SDKs dial the frontend address they are configured with (Connection.connect / NativeConnection.connect `address`, conventionally TEMPORAL_ADDRESS) over gRPC, which the http/fetch injector never sees. Interception is the app-read address: the World injects TEMPORAL_ADDRESS=<host>:<port> at this twin (APP_READ_ENDPOINT_ENV in world-runtime/src/init.ts).",
+      "archetype": "engine-control",
+      "protocol": {
+        "declared": "2",
+        "major": 2,
+        "standing": "current"
+      },
+      "transport": "raw-tcp",
+      "resources": [
+        "workflow-execution",
+        "namespace"
+      ],
+      "serveExport": "createTemporalTwinServer"
+    },
     "tiktok": {
       "adoption": {
         "sdks": [],
@@ -4154,11 +4269,11 @@
       "hosts": [
         {
           "host": "api.x.com",
-          "pathPattern": "^(?:/2/media/upload/?|/2/media/upload/initialize/?|/2/media/upload/[0-9]+/(?:append|finalize)/?|/2/tweets/?|/2/tweets/[^/]+/?|/2/tweets/search/recent/?|/2/users/(?!me/?$)[^/]+/?|/2/users/by/username/[^/]+/?|/2/users/[^/]+/mentions/?|/2/users/[^/]+/tweets/?|/2/users/[^/]+/timelines/reverse_chronological/?)$|^/_twin/"
+          "pathPattern": "^(?:/2/media/upload/?|/2/media/upload/initialize/?|/2/media/upload/[0-9]+/(?:append|finalize)/?|/2/tweets/?|/2/tweets/[^/]+/?|/2/tweets/search/recent/?|/2/users/(?!me/?$)[^/]+/?|/2/users/by/username/[^/]+/?|/2/users/[^/]+/mentions/?|/2/users/[^/]+/tweets/?|/2/users/[^/]+/timelines/reverse_chronological/?)$|^/_twin/(?!assets/consent\\.(?:js|css)$)"
         },
         {
           "host": "api.twitter.com",
-          "pathPattern": "^(?:/2/media/upload/?|/2/media/upload/initialize/?|/2/media/upload/[0-9]+/(?:append|finalize)/?|/2/tweets/?|/2/tweets/[^/]+/?|/2/tweets/search/recent/?|/2/users/(?!me/?$)[^/]+/?|/2/users/by/username/[^/]+/?|/2/users/[^/]+/mentions/?|/2/users/[^/]+/tweets/?|/2/users/[^/]+/timelines/reverse_chronological/?)$|^/_twin/"
+          "pathPattern": "^(?:/2/media/upload/?|/2/media/upload/initialize/?|/2/media/upload/[0-9]+/(?:append|finalize)/?|/2/tweets/?|/2/tweets/[^/]+/?|/2/tweets/search/recent/?|/2/users/(?!me/?$)[^/]+/?|/2/users/by/username/[^/]+/?|/2/users/[^/]+/mentions/?|/2/users/[^/]+/tweets/?|/2/users/[^/]+/timelines/reverse_chronological/?)$|^/_twin/(?!assets/consent\\.(?:js|css)$)"
         }
       ],
       "archetype": "crud",
@@ -4241,11 +4356,11 @@
         },
         {
           "host": "api.x.com",
-          "pathPattern": "^/2/(?:oauth2/(?:token|revoke)|users/me)/?$"
+          "pathPattern": "^/2/(?:oauth2/(?:token|revoke)|users/me)/?$|^/oauth/(?:request_token|authorize|authenticate|access_token)/?$|^/1\\.1/oauth/invalidate_token(?:\\.json)?/?$|^/_twin/assets/consent\\.(?:js|css)$"
         },
         {
           "host": "api.twitter.com",
-          "pathPattern": "^/2/(?:oauth2/(?:token|revoke)|users/me)/?$"
+          "pathPattern": "^/2/(?:oauth2/(?:token|revoke)|users/me)/?$|^/oauth/(?:request_token|authorize|authenticate|access_token)/?$|^/1\\.1/oauth/invalidate_token(?:\\.json)?/?$|^/_twin/assets/consent\\.(?:js|css)$"
         }
       ],
       "archetype": "crud",
@@ -4263,7 +4378,11 @@
         "access_token",
         "refresh_token",
         "grant",
-        "rate_window"
+        "rate_window",
+        "oauth1_app",
+        "oauth1_request_token",
+        "oauth1_token",
+        "oauth1_grant"
       ],
       "serveExport": "createXIdentityTwinServer"
     },

package/dist/inject.cjs

@@ -678,7 +678,7 @@ function fakeClientRequest(origin, method, fullPath, headers, callback) {
 
 // --- unclaimed path on a twinned shared host: refuse LOUDLY, never mis-route -----------------
 // The Cal.com incident class: a host two vendors share (www.googleapis.com) is twinned, the
-// request's PATH belongs to neither twin (`/calendar/v3/*` — Google Calendar has no pack), and
+// request's PATH belongs to neither twin (`/drive/v3/*` — Google Drive has no pack; `/calendar/v3/*` was the case until the googlecalendar pack), and
 // the old catch-all matcher answered it from the WRONG pack with a vendor-shaped 404: fails open
 // AND plausible. The operator declared this host virtualized, so the traffic must not leak to the
 // real vendor either. The only honest outcome is a refusal that NAMES the situation.
@@ -1092,6 +1092,51 @@ function restore() {
 
 module.exports = { install, restore, readMap, resolveTwin, twinUrlVendor, twinnedHostVendors, unclaimedTwinnedHostPathMessage, appForwardHeaders, VENDOR_HOSTS };
 
+// WORLD TIME: an application process keeps the World's time, as its twins do (worldNow(), world-clock.ts). A World's
+// clock (TWIN_WORLD_CLOCK_FILE, one of world-clock.cjs's two forms) is read at most once a second, so a clock moved
+// while the application runs applies within a second; with no clock set, the process keeps the machine's time.
+// `Date` is the machine's own, wrapped so its `now()` and argument-less construction read the World's time; every other use
+// (a parsed date, `Date.UTC`, arithmetic, timers, `performance.now()`) is unchanged. The machine's own `Date.now` is
+// left under a global symbol, so the kernel's worldNow() applies a running clock's offset once in a process like this.
+// Without this, time moved in a World reaches its twins and not its application: a token the twins sign by the
+// World's time is refused by the application's (dub-stress findings row 107).
+function installWorldTime() {
+  const file = process.env.TWIN_WORLD_CLOCK_FILE;
+  if (!file || globalThis[Symbol.for('volter.machineDateNow')]) return;
+  const fs = require('fs');
+  const { parseClock, clockNowMs } = require('./world-clock.cjs');
+  const MachineDate = Date;
+  const machineNow = MachineDate.now.bind(MachineDate);
+  let held = { checkedAt: -Infinity, mtimeMs: -1, clock: null };
+  const clock = () => {
+    const wall = machineNow();
+    if (wall - held.checkedAt < 1000) return held.clock;
+    held.checkedAt = wall;
+    try {
+      const mtimeMs = fs.statSync(file).mtimeMs;
+      if (mtimeMs !== held.mtimeMs) held = { checkedAt: wall, mtimeMs, clock: parseClock(fs.readFileSync(file, 'utf8')) };
+    } catch (error) {
+      // no clock: the machine's time; a clock caught mid-write keeps the last one read until the next look
+      if (error && error.code === 'ENOENT') held = { checkedAt: wall, mtimeMs: -1, clock: null };
+    }
+    return held.clock;
+  };
+  const worldMs = () => { const c = clock(); return c ? clockNowMs(c, machineNow()) : machineNow(); };
+  // the machine's own Date, wrapped rather than subclassed, so identity holds everywhere: dates Node makes itself
+  // (a file's mtime, structuredClone, a worker's message) are `instanceof Date`, `d.constructor === Date` stays true,
+  // and Date.prototype is the machine's; only now() and argument-less construction read the World's time
+  const WorldDate = new Proxy(MachineDate, {
+    construct: (target, args, newTarget) => Reflect.construct(target, args.length ? args : [worldMs()], newTarget === WorldDate ? target : newTarget),
+    // called as a function, Date() answers the current time's string, as the machine's does
+    apply: () => new MachineDate(worldMs()).toString(),
+  });
+  Object.defineProperty(globalThis, Symbol.for('volter.machineDateNow'), { value: machineNow, enumerable: false });
+  MachineDate.now = worldMs;
+  Object.defineProperty(MachineDate.prototype, 'constructor', { value: WorldDate, writable: true, configurable: true, enumerable: false });
+  globalThis.Date = WorldDate;
+}
+
 // Auto-install as a preload (`--require`); strict refusal also applies without twin URLs.
 install();
+installWorldTime();
 installPrismaAdapterShim();

package/dist/src/actions.d.ts

@@ -192,6 +192,30 @@ export declare function projectedPreconditionValue(precondition: TwinActionPreco
 export declare function projectResources(service: string, root?: string, opts?: {
     until?: string;
 }): TwinResource[];
+/** A read of another pack's store that cannot choose: the subject it looks for (or, with none named, the store itself)
+ *  is held by more than one service of the World. A reader answers it as the vendor answers a credential it cannot
+ *  resolve; it is never a server error. */
+export declare class OwnerStoreAmbiguousError extends Error {
+    constructor(owner: string, roots: string[], subject?: {
+        type: string;
+        id: string;
+    });
+}
+/**
+ * ANOTHER pack's rows, read by contract (architecture A3: one vendor's store split across two packs, xidentity's tokens
+ * read by x, googleoauth's by googlecalendar; scripts/architecture.test.ts holds the declared reader-owner pairs): the
+ * owner's tree, from wherever the World keeps the owner's store (`ownerStoreRoots`). Read only: the rows are frozen and
+ * shared. It claims no journal identity (the twin answering is the reader).
+ *
+ * With `subject`, the store that holds that subject (the token a request presents): `[]` when none does, and
+ * `OwnerStoreAmbiguousError` only when more than one does, so a second service running the owning pack never breaks a
+ * lookup of what only one of them issued. Without it, the one store there is, and `OwnerStoreAmbiguousError` when the
+ * World holds two.
+ */
+export declare function projectOwnerResources(owner: string, root?: string, subject?: {
+    type: string;
+    id: string;
+}): readonly TwinResource[];
 /** The local → vendor id aliases the landed copies carry: a read by the id a caller was handed before
  *  its write was performed resolves to the row the vendor now owns. */
 export declare function subjectAliases(service: string, root?: string): Map<string, string>;