@volter/world-core 3.0.18 → 3.0.20

package/dist/src/pack-fetch.js

@@ -6,7 +6,7 @@
 // one of them is answered over the contract's context, which the kernel opens: a pack opens none, reads the tree and
 // writes it only through one.
 import { ORIGINAL_PATH_HEADER } from "./sigv4.js";
-import { TWIN_PREFIX_HEADER } from "./twin-fetch.js";
+import { placedCookies, TWIN_PREFIX_HEADER } from "./twin-fetch.js";
 import { PREFIX_PARAMS_HEADER } from "./derived.js";
 import { withHeaders } from "./with-headers.js";
 import { authRefusal, bindSemantics, contextFor, LANE_HEADER, SCENARIO_DECISION_HEADER, coreFor, crossCutting, derivedRequestScopes, vendorError } from "./derived-core.js";
@@ -17,6 +17,9 @@ import { getActiveWorldStore } from "./world-store.js";
 import { runWithCorrelationId } from "./actions.js";
 import { deferPerform, performRequestGroup, RefusedWriteError, VendorWriteError } from "./head.js";
 import { withCors } from "./cors.js";
+import { contentAddressOf } from "./content-route.js";
+import { getPack } from "./packRegistry.js";
+import { hostRules } from '../vendor-hosts.cjs';
 import { socketUpgrade } from "./sockets.js";
 import { MACHINE_POOL, POOL_KINDS } from "./machines.js";
 import { applyTwinWrite } from "./serve.js";
@@ -112,6 +115,7 @@ export function createPackFetch(parts, options = {}) {
         ...(options.clock ? { clock: options.clock } : {}),
         ...(options.database !== undefined ? { database: options.database, readOnly: options.readOnly ?? false } : {}),
         ...(parts.tenant ? { tenant: parts.tenant } : {}),
+        ...(options.application ? { application: options.application } : {}),
     };
     // a command table's surface (Redis's, a vendor that carries Redis over HTTP) names no HTTP operation: its wire is the
     // pack's front (its `around`), and the table is the denominator the grade counts
@@ -267,6 +271,78 @@ export function createPackFetch(parts, options = {}) {
     };
     const rootServes = (method, path) => Boolean(matchOperation(routes, method, path));
     const lane = m.lanes ? laneRouter(m.vendor, m.lanes, parts.lanes ?? {}, rootServes) : undefined;
+    // at a World's place, a page's asset or upload on another of the pack's content hosts is `<base>/@<host>/<path>`
+    // (architecture, "A page at a World's place"): answered by the built content screen that names that host exactly,
+    // routed from it, and by nothing else; a request naming no such host is general routing's
+    const contentScreens = screens.filter((s) => s.decl.kind === 'content');
+    for (const s of contentScreens)
+        if (s.decl.yieldsToApi)
+            throw new Error(`${m.vendor}: the content screen ${s.decl.id} declares yieldsToApi; a content screen answers its host's requests alone (architecture, "Screens")`);
+    const contentHosts = [...new Set(contentScreens.flatMap((s) => [s.decl.host, ...(s.decl.hosts ?? [])]).filter((h) => !/[{<]/.test(h)).map((h) => h.toLowerCase()))];
+    const contentNotFound = (host, path) => {
+        const nf = m.notFound;
+        return vendorError(m, { status: nf.status, message: nf.message.replace(/\{object\}/g, host).replace(/\{id\}/g, path), ...(nf.code !== undefined ? { code: nf.code } : {}), ...(nf.kind !== undefined ? { kind: nf.kind } : {}) });
+    };
+    /** A request at a World's place for `/@<host>/<path>`, `<host>` one a built content screen of this unit names exactly:
+     *  that screen's answer, or the pack's not-found for what the host or the screen does not take. The path is held to
+     *  the descriptor's host rules (`rules`: this unit's, or its vendor's for a lane), read as the injector reads them.
+     *  Undefined for any other request. */
+    // the descriptor's host rules: this unit's, or, for a lane (which declares none), its vendor's as registered
+    const descriptorHosts = () => m.descriptor?.hosts ?? getPack(m.vendor)?.hosts;
+    const atContentHost = async (request, rules = descriptorHosts()) => {
+        if (!request.headers.has(TWIN_PREFIX_HEADER))
+            return undefined;
+        const url = new URL(request.url);
+        const address = contentAddressOf(url.pathname);
+        if (!address || !contentHosts.includes(address.host))
+            return undefined;
+        const { host, path: inner } = address;
+        if (address.refused)
+            return contentNotFound(host, inner);
+        const declared = hostRules(rules);
+        if (declared.names(host) && !declared.takes(host, inner))
+            return contentNotFound(host, inner);
+        const onHost = contentScreens.filter((s) => [s.decl.host, ...(s.decl.hosts ?? [])].some((h) => h.toLowerCase() === host));
+        const method = request.method.toUpperCase();
+        const allowed = (s) => method === 'GET' || method === 'HEAD' || (method === 'POST' && (s.decl.takes ?? []).includes('POST'));
+        // the request as it reaches the content host, through the pack's own routing of a host (its path prefix and labels)
+        url.pathname = inner;
+        const headers = new Headers(request.headers);
+        headers.set('x-volter-twin-original-host', host);
+        const sent = method === 'POST' && request.body ? { body: request.body, duplex: 'half' } : {};
+        const there = routed(new Request(url, { method, headers, signal: request.signal, ...sent }));
+        const path = new URL(there.url).pathname.replace(/\/+$/, '') || '/';
+        const hit = onHost.map((s) => ({ s, hit: s.path(path) })).find((x) => x.hit && allowed(x.s));
+        if (!hit)
+            return contentNotFound(host, inner);
+        const asked = options.readOnly && !isReadOnlyRequest(there) ? withHeaders(there, new Headers([...there.headers, [READ_ONLY_REQUEST_HEADER, '1']])) : there;
+        if (method === 'POST' && ((options.readOnly ?? false) || isReadOnlyRequest(asked)))
+            return refusedReadOnly();
+        if (parts.clock)
+            await runAsVendorMove(async () => parts.clock(await open(new Request(asked.url, m.tenant ? { headers: asked.headers } : {}), 'clock', 'POST', '/_twin/clock', {})));
+        return hit.s.answer(await open(asked, hit.s.decl.id, method, hit.s.decl.path, { ...(hit.s.host(host)?.params ?? {}), ...hit.hit.params }));
+    };
+    /** A request as the kernel reads it: the headers only the kernel names taken off, its body decoded (undefined when it
+     *  does not decode as its Content-Encoding says). */
+    const prepared = async (arrived) => {
+        if (arrived.headers.has(SCENARIO_DECISION_HEADER) || arrived.headers.has(PREFIX_PARAMS_HEADER)) {
+            const headers = new Headers(arrived.headers);
+            headers.delete(SCENARIO_DECISION_HEADER);
+            headers.delete(PREFIX_PARAMS_HEADER);
+            arrived = new Request(arrived, { headers });
+        }
+        return decoded(m, arrived);
+    };
+    const undecodable = (arrived) => vendorError(m, m.encodings?.undecodable ?? { status: 400, message: `the body does not decode as its Content-Encoding (${arrived.headers.get('content-encoding')}) says` });
+    /** The content route at the request's arrival: the answer, or undefined when this unit's content screens name no such
+     *  host. */
+    const answerContent = async (arrived) => {
+        const address = arrived.headers.has(TWIN_PREFIX_HEADER) ? contentAddressOf(new URL(arrived.url).pathname) : undefined;
+        if (!address || !contentHosts.includes(address.host))
+            return undefined;
+        const readable = await prepared(arrived);
+        return readable ? atContentHost(readable) : undecodable(arrived);
+    };
     const fetch = async (arrived) => {
         // the discovery door is the pack's own, whichever lane would take its path
         const asked = new URL(arrived.url).pathname.replace(/\/+$/, '') || '/';
@@ -280,19 +356,18 @@ export function createPackFetch(parts, options = {}) {
             const frames = await parts.board(await open(request, 'board', 'GET', '/twin/board', {}));
             return Response.json({ frames: frames.map((f) => ({ ...f, drawn: drawsUrl(f.url) })) });
         }
+        // `<base>/@<host>/<path>` at a World's place, for a host a built content screen of this pack names, is that screen's
+        // alone (only the kernel names a scenario's decision or a path prefix's parameters: `prepared` takes them off); for
+        // one a lane's names, the lane router sends it to that lane's own fetch, wrapped as any request to it is
+        const own = await answerContent(arrived);
+        if (own)
+            return own;
         const toLane = discovery ? undefined : lane?.(arrived);
         if (toLane)
             return toLane(arrived);
-        // only the kernel names a scenario's decision, or a path prefix's parameters
-        if (arrived.headers.has(SCENARIO_DECISION_HEADER) || arrived.headers.has(PREFIX_PARAMS_HEADER)) {
-            const headers = new Headers(arrived.headers);
-            headers.delete(SCENARIO_DECISION_HEADER);
-            headers.delete(PREFIX_PARAMS_HEADER);
-            arrived = new Request(arrived, { headers });
-        }
-        const readable = await decoded(m, arrived);
+        const readable = await prepared(arrived);
         if (!readable)
-            return vendorError(m, m.encodings?.undecodable ?? { status: 400, message: `the body does not decode as its Content-Encoding (${arrived.headers.get('content-encoding')}) says` });
+            return undecodable(arrived);
         const incoming = routed(readable);
         // a twin started read-only marks every request so, so every context it opens knows (isReadOnlyRequest)
         const request = options.readOnly && !isReadOnlyRequest(incoming) ? withHeaders(incoming, new Headers([...incoming.headers, [READ_ONLY_REQUEST_HEADER, '1']])) : incoming;
@@ -355,8 +430,10 @@ export function createPackFetch(parts, options = {}) {
         // whichever host the twin is reached (its links carry the twin's own base), never a root screen off its own host
         const host = hostOf(request);
         const exact = (s) => [s.decl.host, ...(s.decl.hosts ?? [])].some((h) => !/[{<]/.test(h) && h.toLowerCase() === host);
-        const hits = screens.map((s) => ({ s, hit: s.path(path), onHost: s.host(host) })).filter((x) => x.hit);
         const apiPath = Boolean(matchOperation(routes, request.method, url.pathname, url.searchParams, request.headers));
+        // a screen that yields to the API draws only what no operation names, wherever it would answer (architecture,
+        // "Screens": Hacker News's /login page, whose form posts to POST /login)
+        const hits = screens.map((s) => ({ s, hit: s.path(path), onHost: s.host(host) })).filter((x) => x.hit && !(apiPath && x.s.decl.yieldsToApi));
         // reached at a World's place for the twin (`x-forwarded-prefix`, served-world's wire), the host is the World's: a
         // workspace is shown there by its path alone, its root too (the console frames it so)
         const placed = request.headers.has(TWIN_PREFIX_HEADER);
@@ -421,7 +498,9 @@ export function createPackFetch(parts, options = {}) {
         headers.set('content-type', m.jsonContentType);
         return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
     };
-    const served = m.cors ? withCors(m.cors, labelled) : labelled;
+    const cors = m.cors ? withCors(m.cors, labelled) : labelled;
+    // at a World's place every cookie the twin sets is kept to the twin's base path (twin-fetch.ts, placedCookies)
+    const served = async (request) => placedCookies(request, await cors(request));
     // which paths this pack's API serves, for a vendor's lane router that asks (unlessOnlyRoot)
     const serves = (method, path) => Boolean(matchOperation(routes, method, path));
     // the vendor's sockets: a request to a declared socket's path opens a session of its engine, over a context of the
@@ -434,7 +513,7 @@ export function createPackFetch(parts, options = {}) {
     async (asked) => engineOf()?.serve(asked)) : undefined;
     // what serves each operation: the pack's own, and each lane's
     const owners = () => ({ ...api.owners(), ...lanesOwners(parts.lanes ?? {}) });
-    return derivedRequestScopes(m, Object.assign(served, { owners, serves, workspaces, boards: Boolean(parts.board), draws: drawsUrl, ...(upgrade ? { upgrade } : {}) }));
+    return derivedRequestScopes(m, Object.assign(served, { owners, serves, workspaces, boards: Boolean(parts.board), draws: drawsUrl, contentHosts, ...(upgrade ? { upgrade } : {}) }));
 }
 /** The vendor's gateway over its lanes: the lane a request goes to (a door to the lane that declares it, then the first
  *  route whose conditions all hold, then the default), behind the gateway's CORS; undefined when none takes it. */
@@ -470,6 +549,13 @@ function laneRouter(vendor, decl, lanes, rootServes = () => false) {
     });
     const fallback = decl.default !== undefined ? served(decl.default) : undefined;
     return (request) => {
+        // `<base>/@<host>/<path>` at a World's place, for a host a lane's built content screen names, goes to that lane, before
+        // any lane is picked by the request's host or path: its own fetch answers it by its content route, under the vendor's
+        // host rules (architecture, "A page at a World's place")
+        const address = request.headers.has(TWIN_PREFIX_HEADER) ? contentAddressOf(new URL(request.url).pathname) : undefined;
+        const content = address && Object.keys(lanes).find((l) => lanes[l].fetch.contentHosts?.includes(address.host));
+        if (content)
+            return served(content);
         const path = new URL(request.url).pathname.replace(/\/{2,}/g, '/');
         if (path.startsWith('/_twin/')) {
             const door = doors.find((d) => d.method === request.method && d.matches(path));

package/dist/src/twin-fetch.d.ts

@@ -86,3 +86,11 @@ export interface TwinFetchAdapterConfig {
     responseHeaders?: Record<string, string>;
 }
 export declare function createTwinFetchFromHandler(handler: (request: TwinFetchHandlerRequest) => TwinFetchHandlerResult | Promise<TwinFetchHandlerResult>, config: TwinFetchAdapterConfig): (request: Request) => Promise<Response>;
+/** A twin's answer at a World's place with its cookies kept to the twin: every cookie it sets is scoped to the twin's
+ *  base path there (`Path=/` and no Path become `Path=<prefix>`, which RFC 6265's path-match gives the twin's root
+ *  `<prefix>` and every path under it and no sibling; a path under the vendor's root, `Path=/x`, becomes `<prefix>/x`),
+ *  so one twin's sign-in never reaches a sibling twin served from the same pages origin (architecture, "A page at a
+ *  World's place"). A `__Host-` cookie, which a browser takes only at `Path=/`, is left as set. An answer off a place, at
+ *  a prefix the World never sends (outside `/[A-Za-z0-9._~/-]*`, which twinPublicBase refuses too), or setting no cookie
+ *  is the answer as it is. */
+export declare function placedCookies(request: Request, response: Response): Response;

package/dist/src/twin-fetch.js

@@ -178,3 +178,33 @@ async function readScoped(run) {
         return out.value;
     return { status: 405, body: { error: 'read_only', message: out.refused.message } };
 }
+/** A twin's answer at a World's place with its cookies kept to the twin: every cookie it sets is scoped to the twin's
+ *  base path there (`Path=/` and no Path become `Path=<prefix>`, which RFC 6265's path-match gives the twin's root
+ *  `<prefix>` and every path under it and no sibling; a path under the vendor's root, `Path=/x`, becomes `<prefix>/x`),
+ *  so one twin's sign-in never reaches a sibling twin served from the same pages origin (architecture, "A page at a
+ *  World's place"). A `__Host-` cookie, which a browser takes only at `Path=/`, is left as set. An answer off a place, at
+ *  a prefix the World never sends (outside `/[A-Za-z0-9._~/-]*`, which twinPublicBase refuses too), or setting no cookie
+ *  is the answer as it is. */
+export function placedCookies(request, response) {
+    const prefix = request.headers.get(TWIN_PREFIX_HEADER)?.replace(/\/+$/, '');
+    if (!prefix || !/^\/[A-Za-z0-9._~\/-]*$/.test(prefix))
+        return response;
+    const cookies = response.headers.getSetCookie?.() ?? [];
+    if (!cookies.length || response.status < 200)
+        return response;
+    const scoped = cookies.map((cookie) => {
+        if (/^\s*__Host-/i.test(cookie))
+            return cookie;
+        const path = /;\s*path=([^;]*)/i.exec(cookie)?.[1]?.trim();
+        // already scoped (a lane's answer its vendor passes on): as it is
+        if (path !== undefined && (path === prefix || path.startsWith(`${prefix}/`)))
+            return cookie;
+        const at = !path || path === '/' ? prefix : `${prefix}${path.startsWith('/') ? path : `/${path}`}`.replace(/\/+$/, '');
+        return path === undefined ? `${cookie}; Path=${at}` : cookie.replace(/(;\s*)path=[^;]*/i, `$1Path=${at}`);
+    });
+    const headers = new Headers(response.headers);
+    headers.delete('set-cookie');
+    for (const cookie of scoped)
+        headers.append('set-cookie', cookie);
+    return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+}

package/dist/vendor-hosts.cjs

@@ -55,6 +55,39 @@ const COMPILED = new Map();
 /** The hand table's keys, before any pack's rules: a pack installed later replaces its hand entry in place (keeping its
  *  position, which decides who answers a shared host first), where the built-in facts may not declare one twice. */
 const HAND = new Set(Object.keys(VENDOR_HOSTS));
+/** One host rule as a predicate over (hostname, pathname?): its one selector (host | suffix | hostPattern) and its
+ *  pathPattern, a path left out matching any. */
+function compileHostRule(rule, where) {
+  const selectors = ['host', 'suffix', 'hostPattern'].filter((k) => rule[k] !== undefined).length;
+  if (selectors !== 1) throw new Error(`inject: ${where} rule ${JSON.stringify(rule)} — exactly one of host | suffix | hostPattern (pack-facts.json is hand-edited or stale)`);
+  const hostRe = rule.hostPattern === undefined ? null : new RegExp(rule.hostPattern);
+  const pathRe = rule.pathPattern === undefined ? null : new RegExp(rule.pathPattern);
+  return (h, p) =>
+    (rule.host !== undefined ? h === rule.host : rule.suffix !== undefined ? h.endsWith(rule.suffix) : hostRe.test(h))
+    && (pathRe === null || p === undefined || pathRe.test(p));
+}
+
+/** A pack's host rules (its descriptor's `hosts`) read as the injector reads them: `names(host)`, whether any include
+ *  rule's selector names the host, whatever the path; `takes(host, path)`, whether the request is the pack's (under
+ *  one of its keys, an include matches and no exclude does). The content route at a World's place holds a
+ *  `<base>/@<host>/<path>` to it (pack-fetch.ts). */
+function hostRules(rules) {
+  const byKey = new Map();
+  for (const rule of rules || []) {
+    const key = rule.key === undefined ? '' : rule.key;
+    if (!byKey.has(key)) byKey.set(key, []);
+    byKey.get(key).push(rule);
+  }
+  const keys = [...byKey.values()].map((keyRules) => ({
+    includes: keyRules.filter((r) => r.exclude !== true).map((r) => compileHostRule(r, 'a pack')),
+    excludes: keyRules.filter((r) => r.exclude === true).map((r) => compileHostRule(r, 'a pack')),
+  }));
+  return {
+    names: (h) => keys.some((k) => k.includes.some((m) => m(h))),
+    takes: (h, p) => keys.some((k) => k.includes.some((m) => m(h, p)) && !k.excludes.some((m) => m(h, p))),
+  };
+}
+
 function compilePackHosts(packs, overlay) {
   for (const vendor of Object.keys(packs)) {
     const rules = packs[vendor].hosts;
@@ -77,15 +110,7 @@ function compilePackHosts(packs, overlay) {
       if (VENDOR_HOSTS[key] && !(overlay && HAND.has(key))) {
         throw new Error(`inject: key "${key}" (pack ${vendor}) is declared twice — on this descriptor and in the hand VENDOR_HOSTS table or another pack's descriptor; a key has one home.`);
       }
-      const compile = (rule) => {
-        const selectors = ['host', 'suffix', 'hostPattern'].filter((k) => rule[k] !== undefined).length;
-        if (selectors !== 1) throw new Error(`inject: key "${key}" (pack ${vendor}) rule ${JSON.stringify(rule)} — exactly one of host | suffix | hostPattern (pack-facts.json is hand-edited or stale)`);
-        const hostRe = rule.hostPattern === undefined ? null : new RegExp(rule.hostPattern);
-        const pathRe = rule.pathPattern === undefined ? null : new RegExp(rule.pathPattern);
-        return (h, p) =>
-          (rule.host !== undefined ? h === rule.host : rule.suffix !== undefined ? h.endsWith(rule.suffix) : hostRe.test(h))
-          && (pathRe === null || p === undefined || pathRe.test(p));
-      };
+      const compile = (rule) => compileHostRule(rule, `key "${key}" (pack ${vendor})`);
       const includes = keyRules.filter((r) => r.exclude !== true).map(compile);
       const excludes = keyRules.filter((r) => r.exclude === true).map(compile);
       VENDOR_HOSTS[key] = (h, p) => includes.some((m) => m(h, p)) && !excludes.some((m) => m(h, p));
@@ -141,4 +166,4 @@ function twinOrigins(env) {
   return map;
 }
 
-module.exports = { VENDOR_HOSTS, addPackHosts, isVendorHost, vendorsOfHost, twinEnvStem, twinOrigins };
+module.exports = { VENDOR_HOSTS, hostRules, addPackHosts, isVendorHost, vendorsOfHost, twinEnvStem, twinOrigins };

package/dist/vendor-hosts.d.cts

@@ -6,3 +6,6 @@ export function vendorsOfHost(hostname: string): string[];
 export function twinEnvStem(vendor: string): string;
 /** The vendors whose twin `env` points at, each with its origin. */
 export function twinOrigins(env: Readonly<Record<string, string | undefined>>): Record<string, string>;
+/** A pack's host rules (its descriptor's `hosts`, as data) read as the injector reads them: whether any include names a
+ *  host whatever the path, and whether a request to a host and path is the pack's. */
+export function hostRules(rules: ReadonlyArray<{ host?: string; suffix?: string; hostPattern?: string; pathPattern?: string; key?: string; exclude?: true }> | undefined): { names(hostname: string): boolean; takes(hostname: string, pathname: string): boolean };

package/generated/pack-facts.json

@@ -1137,6 +1137,48 @@
       },
       "serveExport": "createGroqTwinServer"
     },
+    "hackernews": {
+      "adoption": {
+        "sdks": [],
+        "envStems": [
+          "HN",
+          "HACKERNEWS"
+        ]
+      },
+      "hosts": [
+        {
+          "host": "hacker-news.firebaseio.com"
+        },
+        {
+          "host": "news.ycombinator.com"
+        }
+      ],
+      "archetype": "crud",
+      "protocol": {
+        "declared": "3",
+        "major": 3,
+        "standing": "current"
+      },
+      "transport": "rest",
+      "resources": [
+        "item",
+        "user",
+        "_vote",
+        "_person",
+        "_web_session",
+        "_web_session_issue"
+      ],
+      "endpointEnvNone": "Hacker News publishes no SDK: clients fetch https://hacker-news.firebaseio.com/v0 directly and people use news.ycombinator.com in a browser, both reached by host",
+      "credentialDoor": {
+        "path": "/_twin/app-credentials",
+        "body": {},
+        "fill": {
+          "HN_USERNAME": "acct",
+          "HN_PASSWORD": "pw"
+        }
+      },
+      "serveExport": "createHackernewsTwinServer"
+    },
     "hubspot": {
       "adoption": {
         "sdks": [
@@ -1844,6 +1886,88 @@
       },
       "serveExport": "createPosthogTwinServer"
     },
+    "reddit": {
+      "adoption": {
+        "sdks": [
+          "snoowrap"
+        ],
+        "pypi": [
+          "praw",
+          "asyncpraw"
+        ],
+        "envStems": [
+          "REDDIT"
+        ]
+      },
+      "hosts": [
+        {
+          "host": "oauth.reddit.com"
+        },
+        {
+          "host": "www.reddit.com"
+        },
+        {
+          "host": "reddit.com"
+        },
+        {
+          "host": "reddit-uploaded-media.s3-accelerate.amazonaws.com"
+        },
+        {
+          "host": "reddit-uploaded-video.s3-accelerate.amazonaws.com"
+        },
+        {
+          "host": "v.redd.it"
+        },
+        {
+          "host": "i.redd.it"
+        },
+        {
+          "host": "preview.redd.it"
+        },
+        {
+          "host": "external-preview.redd.it"
+        },
+        {
+          "host": "b.thumbs.redditmedia.com"
+        }
+      ],
+      "archetype": "crud",
+      "protocol": {
+        "declared": "3",
+        "major": 3,
+        "standing": "current"
+      },
+      "transport": "rest",
+      "resourcesUnreachable": {},
+      "resources": [
+        "account",
+        "subreddit",
+        "link",
+        "comment",
+        "asset",
+        "app",
+        "_access_token",
+        "_token_issue",
+        "_client_secret",
+        "_rate_window",
+        "_vote",
+        "_membership",
+        "_person",
+        "_web_session",
+        "_web_session_issue"
+      ],
+      "endpointEnvNone": "Reddit's clients name oauth.reddit.com and www.reddit.com themselves (the campaign's sender writes them as constants); the World's injector routes those hosts, and no client of the demand reads a base-URL variable",
+      "credentialDoor": {
+        "path": "/_twin/app-credentials",
+        "body": {
+          "username": "volter"
+        },
+        "fill": {
+          "REDDIT_ACCESS_TOKEN": "access_token"
+        }
+      },
+      "serveExport": "createRedditTwinServer"
+    },
     "resend": {
       "adoption": {
         "pypi": [
@@ -2817,27 +2941,27 @@
         },
         {
           "host": "x.com",
-          "pathPattern": "^/i/oauth2/authorize/?$|^/_twin/|^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$"
+          "pathPattern": "^/i/oauth2/authorize/?$|^/_twin/|^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$|^/home/?$|^/i/flow/login/?$|^/$"
         },
         {
           "host": "twitter.com",
-          "pathPattern": "^/i/oauth2/authorize/?$|^/_twin/|^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$"
+          "pathPattern": "^/i/oauth2/authorize/?$|^/_twin/|^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$|^/home/?$|^/i/flow/login/?$|^/$"
         },
         {
           "host": "www.x.com",
-          "pathPattern": "^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$"
+          "pathPattern": "^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$|^/home/?$|^/i/flow/login/?$|^/$"
         },
         {
           "host": "www.twitter.com",
-          "pathPattern": "^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$"
+          "pathPattern": "^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$|^/home/?$|^/i/flow/login/?$|^/$"
         },
         {
           "host": "mobile.twitter.com",
-          "pathPattern": "^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$"
+          "pathPattern": "^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$|^/home/?$|^/i/flow/login/?$|^/$"
         },
         {
           "host": "mobile.x.com",
-          "pathPattern": "^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$"
+          "pathPattern": "^/(?!_twin/)[A-Za-z0-9_]{1,15}/status/[0-9]{1,19}/?$|^/(?!(?:i|en|home|explore|notifications|messages|settings|search|compose|login|logout|signup|tos|privacy|about|account|intent|share|hashtag|lists|bookmarks|jobs|download|grok|premium|communities|creators|twin|_twin)/?$)[A-Za-z0-9_]{1,15}/?$|^/home/?$|^/i/flow/login/?$|^/$"
         },
         {
           "host": "pbs.twimg.com",
@@ -2863,7 +2987,6 @@
         "oauth_client",
         "oauth1_app",
         "account",
-        "session",
         "auth_request",
         "post",
         "rate_limit",
@@ -2873,6 +2996,7 @@
         "repost",
         "bookmark",
         "_impressions",
+        "_card",
         "_grant",
         "_oauth1_grant",
         "_rate_window",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/world-core",
-  "version": "3.0.18",
+  "version": "3.0.20",
   "description": "The kernel of Volter World: one log per twin, branches as pointers, checkpoints, the fold that keeps a twin current, the head that performs a write against the vendor, references, and the git plane. A twin package builds on it; the runtime serves it.",
   "keywords": [
     "twin",

package/src/content-route.ts

@@ -0,0 +1,24 @@
+// THE CONTENT ROUTE'S ADDRESS (architecture, "Screens", "A page at a World's place"): at a World's place, what a page
+// reaches on another of the pack's hosts that a content screen serves is `<base>/@<host>/<path>`. This reads that
+// address as a browser would have written it: a doubled slash collapsed, `%40` for `@`, the host's case, a trailing dot
+// and a default port (80, 443) normalised away. What it reads is a candidate only: the route is taken when the host is
+// one a built content screen names (pack-fetch.ts), and a request naming no such host is general routing's, as before.
+
+/** A `/@<host>/<path>` address: the host normalised, the path under it (slashes collapsed), and why the spelling cannot
+ *  be the host's content (`refused`: a port other than the default), when it cannot. */
+export type ContentAddress = { host: string; path: string; refused?: string };
+
+export function contentAddressOf(pathname: string): ContentAddress | undefined {
+  const collapsed = pathname.replace(/\/{2,}/g, '/');
+  const named = /^\/(?:@|%40)([^/]+)(\/.*)?$/i.exec(collapsed);
+  if (!named) return undefined;
+  let token: string;
+  try { token = decodeURIComponent(named[1]!).toLowerCase(); } catch { return undefined; }
+  const at = /^([^:]*)(?::(\d*))?$/.exec(token);
+  if (!at) return undefined;
+  const host = at[1]!.replace(/\.$/, '');
+  if (!/^[a-z0-9_-]+(?:\.[a-z0-9_-]+)+$/.test(host)) return undefined;
+  const port = at[2];
+  const refused = port && port !== '80' && port !== '443' ? `port ${port} is not the host's` : undefined;
+  return { host, path: named[2] ?? '/', ...(refused ? { refused } : {}) };
+}