@volter/twin-standard 1.0.31 → 1.0.33

package/src/pack-facts.ts

@@ -0,0 +1,240 @@
+// Published descriptor compiler. Pack locations are explicit; imports happen only when called by a publisher.
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { PACK_ARCHETYPES, PROTOCOL_VERSION, protocolStanding } from '@volter/world-core/runtime';
+
+export type PackFacts = {
+  /** Explicit vendor-server backing; this entry declares no pack protocol or factory. */
+  serverBacking?: { command: string };
+  maxRequestBodySize?: number;
+  adoption?: { sdks?: string[]; pypi?: string[]; scopes?: string[]; envStems?: string[]; worldIds?: string[]; tools?: Array<{ package: string; usage: 'build' | 'deployment' }>; configFiles?: Array<{ file: string; usage: 'application' | 'build' | 'deployment'; when?: string }> };
+  hosts?: Array<{ host?: string; suffix?: string; hostPattern?: string; pathPattern?: string; demandPathPattern?: string | false; key?: string; exclude?: true }>;
+  hostsNone?: string;
+  hostsClaimed?: { door: string; note: string };
+  /** The subject types the twin projects (packRegistry `resources`) — invariant R2 at the resource
+   *  level checks a replay creates every one of them. */
+  resources?: string[];
+  /** The wire transport class (packRegistry PackTransport) — the invariant matrix keys
+   *  variants off it too (a raw-tcp twin has no workerd fetch path, so R12b is n/a). */
+  transport?: string;
+  /** Optional native frontend of the same state owner, selected explicitly on the pack CLI. */
+  /** The serve-family (packRegistry PackArchetype) — the axis the invariant matrix keys
+   *  strictness off. Closed enum, REQUIRED: every pack declares one (the catalog was
+   *  fully classified 2026-09-02; the scaffolder's A1 TODO makes a new pack's
+   *  ratification unskippable because an undeclared archetype is RED here). */
+  archetype?: string;
+  /** R16: the protocol major the package targets and its standing against this kernel. */
+  protocol?: { declared?: string; major: number; standing: 'current' | 'deprecated' | 'refused' | 'assumed' };
+  /** R20: pack-shipped asset paths (relative to the pack dir) the serve path reads through the seam. */
+  assets?: string[];
+  /** R2: declared types no replay can create, each with its reason (adopted debt, legible). */
+  resourcesUnreachable?: Record<string, string>;
+  endpointEnv?: { name: string; templates?: Record<string, string> };
+  endpointEnvNone?: string;
+  /** The door that issues the application a credential the twin accepts (see TwinPack.credentialDoor). */
+  credentialDoor?: { path: string; body: Record<string, unknown>; fill: Record<string, string> };
+  credentialIssuer?: string;
+  /** The Prisma driver adapter this database twin is reached through (see TwinPack.prismaAdapter). */
+  prismaAdapter?: { adapter: string; export: string; urlEnv: string };
+  /** The managed-infrastructure kind this pack is the World's backing for (architecture.md, "The descriptor"). */
+  managedService?: { kind: 'redis' | 'mongodb'; scheme: string; note: string };
+  /** The World's managed database the runtime binds the twin to (see TwinPack.managedDatabase). */
+  managedDatabase?: { kind: 'postgres'; arg: string; note: string };
+  /** Listeners the twin opens beside its main port (see TwinPack.sidePorts). */
+  sidePorts?: Array<{ name: string; option: string; flag: string; path?: string; note: string }>;
+  /** DERIVED, never declared: the pack's `create<Name>TwinServer` factory export — the
+   *  `({port,root,readOnly}) => {port,stop}` contract the colocated host mounts
+   *  (world-runtime/src/host.ts). Read off the module's own exports because the name is not
+   *  mechanically derivable from the vendor string (createUpstashRedisTwinServer,
+   *  createGoogleOAuthTwinServer); the export itself is the single source of truth. Consumed
+   *  by `volter-world init` to emit `colocate:` service entries (runtime contract R2a). */
+  serveExport?: string;
+};
+
+export type PackFactsFile = {
+  '//': string;
+  /** Vendor → facts from its current descriptor or explicit vendor-server backing. */
+  packs: Record<string, PackFacts>;
+  /** vendor packs whose index.ts exports no `pack` descriptor yet — the migration worklist. */
+  undeclared: string[];
+};
+
+const sortObject = <T>(o: Record<string, T>): Record<string, T> =>
+  Object.fromEntries(Object.entries(o).sort(([a], [b]) => a.localeCompare(b)));
+
+/** Host rules are DATA with a closed grammar (packRegistry HostRule): exactly one selector, regex
+ *  sources that compile, keys that are one pack's alone (and never another pack's vendor id),
+ *  and an exclude only where the same key has something to exclude from. */
+function validateHostRules(vendor: string, rules: NonNullable<PackFacts['hosts']>, vendors: string[], claimedKeys: Map<string, string>, worldIds: string[]): void {
+  const keys = new Set<string>();
+  for (const rule of rules) {
+    const selectors = ['host', 'suffix', 'hostPattern'].filter((k) => (rule as Record<string, unknown>)[k] !== undefined);
+    if (selectors.length !== 1) throw new Error(`pack-facts: ${vendor} host rule ${JSON.stringify(rule)} — exactly one of host | suffix | hostPattern`);
+    for (const k of ['hostPattern', 'pathPattern'] as const) {
+      if (rule[k] !== undefined) { try { new RegExp(rule[k]!); } catch (e) { throw new Error(`pack-facts: ${vendor} host rule ${k} ${JSON.stringify(rule[k])} does not compile: ${(e as Error).message}`); } }
+    }
+    if (rule.demandPathPattern !== undefined && rule.demandPathPattern !== false) {
+      if (typeof rule.demandPathPattern !== 'string') throw new Error(`pack-facts: ${vendor} demandPathPattern must be a regex source or false`);
+      try { new RegExp(rule.demandPathPattern); } catch (e) { throw new Error(`pack-facts: ${vendor} demandPathPattern does not compile: ${(e as Error).message}`); }
+    }
+    if (rule.exclude !== undefined && rule.exclude !== true) throw new Error(`pack-facts: ${vendor} host rule ${JSON.stringify(rule)} — exclude is \`true\` or absent, never a falsy flag`);
+    const key = rule.key ?? vendor;
+    // A foreign key is a WORLD identity too: `volter-world init` emits <KEY>_TWIN_URL only for the
+    // ids in adoption.worldIds (covers.ts injectorVendorKeysFor), so a key not listed there would
+    // route in the injector and never be wired by the world — and a pack claiming ONLY foreign
+    // keys would leave its own <VENDOR>_TWIN_URL inert while looking covered.
+    if (key !== vendor && !worldIds.includes(key)) throw new Error(`pack-facts: ${vendor} claims key "${key}" but does not list it in adoption.worldIds — the routing identity must also be a world identity`);
+    if (!/^[a-z0-9-]+$/.test(key)) throw new Error(`pack-facts: ${vendor} host rule key ${JSON.stringify(key)} — keys are [a-z0-9-]+ (the <KEY>_TWIN_URL stem)`);
+    if (key !== vendor && vendors.includes(key)) throw new Error(`pack-facts: ${vendor} claims key "${key}", which is another pack's vendor id — a pack's hosts are its own`);
+    const owner = claimedKeys.get(key);
+    if (owner !== undefined && owner !== vendor) throw new Error(`pack-facts: key "${key}" is claimed by both ${owner} and ${vendor} — a key belongs to one pack`);
+    claimedKeys.set(key, vendor);
+    keys.add(key);
+  }
+  for (const key of keys) {
+    if (rules.filter((r) => (r.key ?? vendor) === key).every((r) => r.exclude === true)) throw new Error(`pack-facts: ${vendor} key "${key}" has only exclude rules — nothing to exclude from`);
+  }
+  // A pack may answer ONLY under foreign keys (aws: the consolidated twin has no `aws` host and
+  // AWS_TWIN_URL is null by design) — the worldIds rule above is what makes that explicit.
+}
+
+/** Compile descriptors at explicit package directories; no repository layout or publisher namespace is assumed. */
+export async function compilePackFacts(dirs: Array<{ vendor: string; dir: string }>): Promise<PackFactsFile> {
+  const claimedKeys = new Map<string, string>();
+  const claimedTools = new Map<string, string>();
+  const packDirs = new Map(dirs.map((e) => [e.vendor, e.dir] as const));
+  const vendors = [...packDirs.keys()].sort();
+  const packs: Record<string, PackFacts> = {};
+  const undeclared: string[] = [];
+  for (const vendor of vendors) {
+    const entry = join(packDirs.get(vendor)!, 'src', 'index.ts');
+    if (!existsSync(entry)) { undeclared.push(vendor); continue; }
+    const mod = await import(entry);
+    const pack = mod.pack;
+    if (pack === undefined || typeof pack.vendor !== 'string') { undeclared.push(vendor); continue; }
+    if (pack.vendor !== vendor) {
+      throw new Error(`pack-facts: ${entry} declares vendor "${pack.vendor}" but lives in ${vendor}/ of the pack repository — the directory IS the identity; rename one.`);
+    }
+    if (pack.hosts !== undefined && pack.hostsNone !== undefined) {
+      throw new Error(`pack-facts: ${vendor} declares BOTH hosts and hostsNone — a ruling is one or the other.`);
+    }
+    if (pack.hosts !== undefined) validateHostRules(vendor, pack.hosts, vendors, claimedKeys, pack.adoption?.worldIds ?? []);
+    for (const tool of pack.adoption?.tools ?? []) {
+      if (!tool || typeof tool.package !== 'string' || tool.package === '' || (tool.usage !== 'build' && tool.usage !== 'deployment')) {
+        throw new Error(`pack-facts: ${vendor} adoption tool must be { package, usage: "build" | "deployment" }`);
+      }
+      const owner = claimedTools.get(tool.package);
+      if (owner !== undefined && owner !== vendor) throw new Error(`pack-facts: tool package "${tool.package}" is claimed by both ${owner} and ${vendor}`);
+      claimedTools.set(tool.package, vendor);
+    }
+    // the World reads its name and templates (init.ts, served-world.ts): a bare string sets nothing, silently
+    const ee = pack.endpointEnv as unknown;
+    if (ee !== undefined && (typeof ee !== 'object' || ee === null || typeof (ee as { name?: unknown }).name !== 'string' || typeof (ee as { note?: unknown }).note !== 'string')) {
+      throw new Error(`pack-facts: ${vendor}'s endpointEnv is ${JSON.stringify(ee)}; it is { name, templates?, note } (the variable the vendor's SDK reads, and why)`);
+    }
+    if (pack.endpointEnv !== undefined && pack.endpointEnvNone !== undefined) {
+      throw new Error(`pack-facts: ${vendor} declares BOTH endpointEnv and endpointEnvNone — a ruling is one or the other.`);
+    }
+    if (pack.archetype === undefined) {
+      throw new Error(`pack-facts: ${vendor} declares no archetype — every pack ratifies its serve-family (closed enum: ${PACK_ARCHETYPES.join(' | ')}; see packRegistry PackArchetype)`);
+    }
+    if (!(PACK_ARCHETYPES as readonly string[]).includes(pack.archetype)) {
+      throw new Error(`pack-facts: ${vendor} declares unknown archetype "${String(pack.archetype)}" (closed enum: ${PACK_ARCHETYPES.join(' | ')})`);
+    }
+    // raw-tcp consistency: the one raw-protocol pack today serves CRUD state over its wire.
+    if (pack.archetype === 'proxy' && pack.transport === 'raw-tcp') {
+      throw new Error(`pack-facts: ${vendor} — proxy archetype over raw-tcp transport is undeclared territory; rule it in the contract first.`);
+    }
+    const facts: PackFacts = {};
+    if (pack.adoption !== undefined) facts.adoption = pack.adoption;
+    if (pack.hosts !== undefined) facts.hosts = pack.hosts;
+    if (pack.hostsNone !== undefined) facts.hostsNone = pack.hostsNone;
+    if (pack.hostsClaimed !== undefined) {
+      if (!pack.hostsClaimed.door.startsWith('/') || !pack.hostsClaimed.note.trim()) throw new Error(`pack-facts: ${vendor} hostsClaimed needs a door path and a note`);
+      if (pack.hosts === undefined) throw new Error(`pack-facts: ${vendor} claims hosts at runtime but declares none of its own: its door is reached on its own host`);
+      facts.hostsClaimed = pack.hostsClaimed;
+    }
+    facts.archetype = pack.archetype;
+    // R16 — the protocol the package targets, and where it stands against this kernel: the kernel serves its own
+    // major and no other, so any other declaration, or none, is refused here.
+    {
+      const standing = protocolStanding(pack.protocol);
+      if (standing.standing === 'refused') throw new Error(`pack-facts: ${vendor} declares protocol ${JSON.stringify(pack.protocol)} — this kernel serves ${PROTOCOL_VERSION} and no other major (runtime contract R16)`);
+      facts.protocol = { ...(pack.protocol !== undefined ? { declared: pack.protocol } : {}), major: standing.major, standing: standing.standing };
+    }
+    facts.transport = pack.transport;
+    if (pack.maxRequestBodySize !== undefined) {
+      if (!Number.isSafeInteger(pack.maxRequestBodySize) || pack.maxRequestBodySize <= 0) throw new Error(`pack-facts: ${vendor} maxRequestBodySize must be positive integer bytes`);
+      facts.maxRequestBodySize = pack.maxRequestBodySize;
+    }
+    if (pack.assets !== undefined) facts.assets = pack.assets; // R20 — what the deploy step places behind the assets binding
+    if (pack.resourcesUnreachable !== undefined) facts.resourcesUnreachable = pack.resourcesUnreachable; // R2 adopted-as-debt, by name and reason
+    facts.resources = pack.resources; // the declared subject types — R2's resource-level claim
+    if (pack.endpointEnv !== undefined) facts.endpointEnv = pack.endpointEnv;
+    if (pack.endpointEnvNone !== undefined) facts.endpointEnvNone = pack.endpointEnvNone;
+    if (pack.credentialDoor !== undefined) facts.credentialDoor = pack.credentialDoor;
+    if (pack.credentialIssuer !== undefined) {
+      if (!/^[a-z][a-z0-9-]*$/.test(pack.credentialIssuer) || pack.credentialIssuer === vendor) throw new Error(`pack-facts: ${vendor} credentialIssuer must name another pack`);
+      facts.credentialIssuer = pack.credentialIssuer;
+    }
+    if (pack.prismaAdapter !== undefined) {
+      if (pack.endpointEnv?.templates?.[pack.prismaAdapter.urlEnv] === undefined && pack.credentialDoor?.fill[pack.prismaAdapter.urlEnv] === undefined) {
+        throw new Error(`pack-facts: ${vendor} declares prismaAdapter.urlEnv "${pack.prismaAdapter.urlEnv}" but neither its endpointEnv templates nor its credentialDoor fill such a variable — the adapter's URL is one of theirs.`);
+      }
+      facts.prismaAdapter = pack.prismaAdapter;
+    }
+    if (pack.managedDatabase !== undefined) {
+      const md = pack.managedDatabase as { kind?: unknown; arg?: unknown; note?: unknown };
+      if (md.kind !== 'postgres') throw new Error(`pack-facts: ${vendor} declares managedDatabase.kind "${String(md.kind)}"; the runtime binds only the World's managed postgres`);
+      if (typeof md.arg !== 'string' || !/^--[a-z][a-z-]*$/.test(md.arg)) throw new Error(`pack-facts: ${vendor} declares managedDatabase.arg "${String(md.arg)}"; it is the serve flag the URL follows (--name)`);
+      if (typeof md.note !== 'string' || md.note.trim() === '') throw new Error(`pack-facts: ${vendor} declares managedDatabase with no note`);
+      facts.managedDatabase = pack.managedDatabase;
+    }
+    if (pack.managedService !== undefined) {
+      const ms = pack.managedService as { kind?: unknown; scheme?: unknown; note?: unknown };
+      if (ms.kind !== 'redis' && ms.kind !== 'mongodb') throw new Error(`pack-facts: ${vendor} declares managedService.kind "${String(ms.kind)}"; the managed-infrastructure kinds a twin backs are redis and mongodb`);
+      if (typeof ms.scheme !== 'string' || !/^[a-z][a-z0-9+.-]*$/.test(ms.scheme)) throw new Error(`pack-facts: ${vendor} declares managedService.scheme "${String(ms.scheme)}"; it is the published URL's scheme`);
+      if (typeof ms.note !== 'string' || ms.note.trim() === '') throw new Error(`pack-facts: ${vendor} declares managedService with no note`);
+      if (pack.bin === undefined) throw new Error(`pack-facts: ${vendor} declares managedService with no bin; the managed infrastructure starts the pack by its bin`);
+      const other = Object.entries(packs).find(([, f]) => f.managedService?.kind === ms.kind);
+      if (other) throw new Error(`pack-facts: ${vendor} and ${other[0]} both declare managedService.kind "${ms.kind}"; one pack backs a kind`);
+      facts.managedService = pack.managedService;
+    }
+    if (pack.sidePorts !== undefined) {
+      for (const side of pack.sidePorts as Array<Record<string, unknown>>) {
+        if (typeof side.name !== 'string' || !/^[a-z][a-z0-9-]*$/.test(side.name)) throw new Error(`pack-facts: ${vendor} declares a side port named "${String(side.name)}"; a name is lowercase (inspect)`);
+        if (typeof side.option !== 'string' || !/^[a-z][A-Za-z0-9]*$/.test(side.option)) throw new Error(`pack-facts: ${vendor} side port ${side.name}: option "${String(side.option)}" is the factory's camelCase option`);
+        if (typeof side.flag !== 'string' || !/^--[a-z][a-z-]*$/.test(side.flag)) throw new Error(`pack-facts: ${vendor} side port ${side.name}: flag "${String(side.flag)}" is the serve flag (--name)`);
+        if (side.path !== undefined && (typeof side.path !== 'string' || !side.path.startsWith('/'))) throw new Error(`pack-facts: ${vendor} side port ${side.name}: path "${String(side.path)}" starts with /`);
+        if (typeof side.note !== 'string' || side.note.trim() === '') throw new Error(`pack-facts: ${vendor} side port ${side.name} has no note`);
+      }
+      facts.sidePorts = pack.sidePorts;
+    }
+    // The serve factory is DERIVED from the module's exports (see PackFacts.serveExport);
+    // a pack exporting SEVERAL factories must declare which one `cli.ts serve` boots — the
+    // exports alone cannot reveal that judgment (linear defaults to its DERIVED server).
+    const serveExports = Object.keys(mod).filter(
+      (k) => /^create\w*TwinServer$/.test(k) && typeof (mod as Record<string, unknown>)[k] === 'function',
+    );
+    if (pack.serveExport !== undefined) {
+      if (!serveExports.includes(pack.serveExport)) {
+        throw new Error(`pack-facts: ${vendor} declares serveExport "${pack.serveExport}" but its index exports no such create*TwinServer factory (found: ${serveExports.join(', ') || 'none'}).`);
+      }
+      facts.serveExport = pack.serveExport;
+    } else if (serveExports.length > 1) {
+      throw new Error(`pack-facts: ${vendor} exports ${serveExports.length} create*TwinServer factories (${serveExports.join(', ')}) — declare \`serveExport\` on its descriptor naming the one cli.ts serve boots.`);
+    } else if (serveExports.length === 1) {
+      facts.serveExport = serveExports[0]!;
+    }
+    if (Object.keys(facts).length > 0) packs[vendor] = facts;
+  }
+  return {
+    '//': 'GENERATED by scripts/pack-facts.ts — current pack descriptors and explicit world-runtime server backings; no prior-artifact entries are retained.',
+    packs: sortObject(packs),
+    undeclared,
+  };
+}
+
+export function renderPackFacts(file: PackFactsFile): string {
+  return JSON.stringify(file, null, 2) + '\n';
+}

package/src/walk/behavior-journey.ts

@@ -12,10 +12,10 @@ import { attributionName } from '../verdict.ts';
 import { redis } from '@volter/world-core';
 import { gzipSync } from 'node:zlib';
 import { parse, visit } from 'graphql';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { databaseSession, type DatabaseSession, getActiveWorldStore, MemoryBlobStore, MemoryWorldStore, setActiveBlobStore, setActiveWorldStore, setDeliveryObserver, setInProcessTwins, type InProcessTwin, type TwinStream, type TwinStreamConnection } from '@volter/world-core/runtime';
-import { VENDOR_HOSTS } from '@volter/world-core/vendor-hosts';
+import { createHostTable, type HostFacts } from '@volter/world-core/host-routing';
 import packFactsDocument from '@volter/world-core/generated/pack-facts.json' with { type: 'json' };
 import { type Captured, type GitStep, type Journey, type JourneyStep, type LineStep, type SocketStep, type SqlStep, type RespStep, isResp, at, captureAt, echoFailures, expandFills, expectFailures, fill, fillJson, formBody, isGit, isLine, isSql, isSocket, isWait, jwtAuthorization, oauth1Authorization, presignedPath, sigv4Headers, waitMs } from './journey-kit.ts';
 import { lanesOf, lineShape, shapeChecker, type LineConnection, type ShapeChecker } from './shape.ts';
@@ -30,7 +30,20 @@ function socketAt(open: string, host: string): { host: string; path: string } {
   return { host: u.host, path: `${u.pathname}${u.search}` };
 }
 
-export function usePacks(dir: string): void { packsRoot = dir; }
+const baselineFacts = packFactsDocument.packs as unknown as HostFacts;
+let walkFacts: HostFacts = baselineFacts;
+let walkHosts = createHostTable(walkFacts).hosts;
+export function usePacks(dir: string): void {
+  packsRoot = dir;
+  const installed: Record<string, HostFacts[string]> = {};
+  for (const name of readdirSync(dir)) {
+    const file = join(dir, name, 'generated/pack-facts.json');
+    if (existsSync(file)) Object.assign(installed, JSON.parse(readFileSync(file, 'utf8')).packs);
+  }
+  walkFacts = { ...baselineFacts, ...installed };
+  walkHosts = createHostTable(walkFacts, Object.keys(installed)).hosts;
+  shapes.clear(); fieldsByVendor.clear();
+}
 const packsDir = (): string => { if (packsRoot === undefined) throw new Error('usePacks(<packs dir>) first'); return packsRoot; };
 
 /** The walk's World: the twin's own code on its in-memory World and blob stores (the backends a serverless
@@ -78,14 +91,14 @@ const shapeOf = (vendor: string): Promise<ShapeChecker | undefined> => { if (!sh
  *  name, as vendor-hosts.cjs compiles them. */
 function routingKeys(vendor: string): string[] {
   const name = vendor.split('/')[0]!;
-  const hosts = ((packFactsDocument as { packs: Record<string, { hosts?: Array<{ key?: string }> }> }).packs[name]?.hosts) ?? [];
-  return [...new Set(hosts.map((rule) => rule.key ?? name))].filter((key) => VENDOR_HOSTS[key] !== undefined);
+  const hosts = walkFacts[name]?.hosts ?? [];
+  return [...new Set(hosts.map((rule) => rule.key ?? name))].filter((key) => walkHosts[key] !== undefined);
 }
 /** Whether one of `keys`' host rules claims `url` (an absolute URL; a path is the life's own host). */
 const claims = (keys: string[], url: string): boolean => {
   if (!/^https?:\/\//.test(url) || !URL.canParse(url)) return false;
   const u = new URL(url);
-  return keys.some((key) => VENDOR_HOSTS[key]!(u.hostname, u.pathname));
+  return keys.some((key) => walkHosts[key]!(u.hostname, u.pathname));
 };
 
 type Answer = { status: number; body: unknown; text: string; headers: Record<string, string> };
@@ -155,7 +168,7 @@ function takeReplies(c: Connection): LineReply[] {
 /** A pack served for a walk the way a World runs it (its server.ts on a port, the World's root and scenario its options):
  *  the walk's requests go to it over HTTP, the vendor's host in their Host header, instead of to the fetch in process;
  *  its sockets are WebSockets to that port, and a line connection (`stream`) is a TCP connection to its protocol port. */
-export type ServedTwin = (root: string, options: { scenarioPath?: string }) => Promise<{ fetch: (request: Request) => Promise<Response>; stop: () => void; socket?: (url: string, headers: Record<string, string>) => WebSocket; stream?: TwinStream }>;
+export type ServedTwin = (root: string, options: { scenarioPath?: string; application?: import('@volter/world-core').PackFetchOptions['application'] }) => Promise<{ fetch: (request: Request) => Promise<Response>; stop: () => void; socket?: (url: string, headers: Record<string, string>) => WebSocket; stream?: TwinStream }>;
 
 export async function walk(journey: Journey, root: string, collect: Failure[], opts: { beats: boolean; verbose?: boolean; hooks?: StepHooks; captured?: Captured; served?: ServedTwin }): Promise<Captured> {
   attributionName(journey.author);
@@ -206,7 +219,7 @@ export async function walk(journey: Journey, root: string, collect: Failure[], o
     }
     return { status: a!.status, ...(a!.headers ? { headers: a!.headers } : {}), ...(a!.bodyError === undefined ? {} : { bodyError: a!.bodyError }), body: typeof a!.body === 'string' ? a!.body : a!.body === undefined ? '' : JSON.stringify(a!.body) };
   };
-  const served = opts.served ? await opts.served(root, scenarioPath ? { scenarioPath } : {}) : undefined;
+  const served = opts.served ? await opts.served(root, { ...(scenarioPath ? { scenarioPath } : {}), application }) : undefined;
   const twin = served ? served.fetch : factory(root, { ...(scenarioPath ? { scenarioPath } : {}), application });
   const shape = await shapeOf(journey.vendor);
   const host = journey.host ?? 'twin.local';

package/src/walk/vendor-fetch.ts

@@ -2,7 +2,6 @@
 // index. What the catalog's walkers drive (behavior journeys, the spec census probe, the invariants)
 // since the worker render left with the v1 host.
 import { join } from 'node:path';
-import packFacts from '@volter/world-core/generated/pack-facts.json' with { type: 'json' };
 import { type PgliteHost, startPgliteHost } from './walk-database.ts';
 import { type TwinStream, worldNow } from '@volter/world-core/runtime';
 import type { PackFetchOptions } from '@volter/world-core';
@@ -20,7 +19,7 @@ export async function vendorFetch(twinDir: string, vendor: string): Promise<Vend
   const name = Object.keys(mod).find((k) => /^create\w+?Fetch$/.test(k) && !/TwinFetch$/.test(k) && typeof mod[k] === 'function');
   if (!name) return undefined;
   const factory = mod[name] as (options: { root: string; database?: string; scenarioPath?: string; application?: ApplicationStandIn }) => ((request: Request) => Response | Promise<Response>) & Record<string, unknown>;
-  if (!declaresManagedDatabase(vendor)) return (root: string, options = {}) => factory({ root, ...options });
+  if (!(mod.pack as { managedDatabase?: unknown } | undefined)?.managedDatabase) return (root: string, options = {}) => factory({ root, ...options });
   // A pack whose data plane is the World's managed Postgres is walked over one, as a World binds it: each World (each
   // root) its own fresh database, started on its first request and stopped when the walk's process ends, its clock the
   // walked World's (set before each request: the walk moves the World clock between steps).
@@ -41,12 +40,6 @@ export async function vendorFetch(twinDir: string, vendor: string): Promise<Vend
 const hosts: PgliteHost[] = [];
 process.once('exit', () => { for (const host of hosts) { try { process.kill(host.pid, 'SIGTERM'); } catch { /* ended */ } } });
 
-/** Whether a pack declares the World's managed database (its descriptor's `managedDatabase`, in the pack facts: this
- *  checkout's kernel's, as the walk's other readers of them import them). */
-function declaresManagedDatabase(vendor: string): boolean {
-  return (packFacts as { packs: Record<string, { managedDatabase?: unknown }> }).packs[vendor.split('/')[0]!]?.managedDatabase !== undefined;
-}
-
 /** Named views of an answer: what a journey step's `view` asserts against. The kit's own: `jwt:<field>`, the payload of the
  *  JSON Web Token at that field of the answer, decoded as the application verifying it reads it (a session token's
  *  claims). A pack's own (`answerViews` in its index) beside them. */