@volter/world-core 3.0.155 → 3.0.156

package/dist/generated/pack-facts.json

@@ -270,9 +270,6 @@
         {
           "host": "api.clerk.com"
         },
-        {
-          "host": "dashboard.clerk.com"
-        },
         {
           "suffix": ".clerk.accounts.dev"
         },
@@ -331,6 +328,65 @@
       },
       "serveExport": "createClerkTwinServer"
     },
+    "clickhouse": {
+      "adoption": {
+        "sdks": [
+          "@clickhouse/client",
+          "@clickhouse/client-web"
+        ],
+        "pypi": [
+          "clickhouse-driver",
+          "clickhouse-connect",
+          "infi-clickhouse-orm"
+        ],
+        "envStems": [
+          "CLICKHOUSE"
+        ]
+      },
+      "hostsNone": "Self-hosted database: its own declared host and allocated listener are supplied by managed infrastructure.",
+      "archetype": "crud",
+      "protocol": {
+        "declared": "3",
+        "major": 3,
+        "standing": "current"
+      },
+      "transport": "rest",
+      "resources": [
+        "database",
+        "table",
+        "row"
+      ],
+      "endpointEnv": {
+        "name": "CLICKHOUSE_URL",
+        "note": "HTTP base URL read by the documented JavaScript client."
+      },
+      "managedService": {
+        "kind": "clickhouse",
+        "scheme": "http",
+        "configurationArg": "--configuration",
+        "originalInputs": {
+          "version": 1,
+          "manifestArg": "--original-inputs",
+          "rootArg": "--original-root",
+          "digestArg": "--original-inputs-sha256",
+          "paths": [
+            "/etc/clickhouse-server",
+            "/docker-entrypoint-initdb.d",
+            "/entrypoint.sh"
+          ]
+        },
+        "note": "One HTTP8123/native9000 process and store; declared operator configuration is installed before listeners."
+      },
+      "sidePorts": [
+        {
+          "name": "native",
+          "option": "nativePort",
+          "flag": "--native-port",
+          "note": "ClickHouse native TCP protocol, normally9000, beside HTTP8123."
+        }
+      ],
+      "serveExport": "createClickhouseTwinServer"
+    },
     "cloudflare": {
       "adoption": {
         "pypi": [
@@ -1014,6 +1070,55 @@
       "endpointEnvNone": "Google generated clients take rootUrl in code; the World routes the declared Calendar API paths.",
       "serveExport": "createGooglecalendarTwinServer"
     },
+    "googlefonts": {
+      "adoption": {
+        "sdks": [],
+        "envStems": [
+          "GOOGLE_FONTS"
+        ]
+      },
+      "hosts": [
+        {
+          "host": "www.googleapis.com",
+          "pathPattern": "^/webfonts/v1/webfonts$"
+        },
+        {
+          "host": "webfonts.googleapis.com",
+          "pathPattern": "^/v1/webfonts$"
+        },
+        {
+          "host": "fonts.googleapis.com",
+          "pathPattern": "^/css$"
+        },
+        {
+          "host": "fonts.gstatic.com",
+          "pathPattern": "^/(s/|l/font$)"
+        }
+      ],
+      "archetype": "crud",
+      "protocol": {
+        "declared": "3",
+        "major": 3,
+        "standing": "current"
+      },
+      "transport": "rest",
+      "resources": [
+        "webfont",
+        "_api_key",
+        "_font_catalog",
+        "_stylesheet",
+        "_font_file"
+      ],
+      "endpointEnvNone": "Pinned helper hardcodes the vendor API and CSS hosts, then downloads their returned gstatic URLs. Scoped host routing preserves these URLs.",
+      "credentialDoor": {
+        "path": "/_twin/app-credentials",
+        "body": {},
+        "fill": {
+          "GOOGLE_FONTS_API_KEY": "api_key"
+        }
+      },
+      "serveExport": "createGooglefontsTwinServer"
+    },
     "googleoauth": {
       "adoption": {
         "sdks": [
@@ -1312,7 +1417,8 @@
           "host": "api.linear.app"
         },
         {
-          "host": "linear.app"
+          "host": "linear.app",
+          "pathPattern": "^/oauth/"
         }
       ],
       "archetype": "crud",
@@ -1332,7 +1438,7 @@
         "comment",
         "issue_label"
       ],
-      "endpointEnvNone": "Linear uses api.linear.app/graphql and linear.app for its workspace and OAuth authorize page; the World claims those hosts",
+      "endpointEnvNone": "Linear uses api.linear.app/graphql and linear.app/oauth/authorize; the World claims the documented hosts",
       "credentialDoor": {
         "path": "/_twin/local-credentials",
         "body": {},
@@ -1516,6 +1622,38 @@
       },
       "serveExport": "createMistralTwinServer"
     },
+    "mongodb": {
+      "adoption": {
+        "sdks": [
+          "mongodb",
+          "mongoose"
+        ],
+        "envStems": [
+          "MONGODB",
+          "MONGO"
+        ]
+      },
+      "hosts": [],
+      "archetype": "crud",
+      "protocol": {
+        "declared": "3",
+        "major": 3,
+        "standing": "current"
+      },
+      "transport": "raw-tcp",
+      "resources": [
+        "collection",
+        "index",
+        "document"
+      ],
+      "endpointEnvNone": "Managed infrastructure injects the connection address from the declared mongodb service; it is a TCP endpoint, with no HTTP API host.",
+      "managedService": {
+        "kind": "mongodb",
+        "scheme": "mongodb",
+        "note": "MongoDB 7.0 wire: standalone, or a declared single-member handshake without sessions; state in the World tree"
+      },
+      "serveExport": "createMongodbTwinServer"
+    },
     "npm-registry": {
       "adoption": {
         "envStems": [
@@ -2025,10 +2163,6 @@
         },
         {
           "host": "inbound-cdn.resend.com"
-        },
-        {
-          "host": "resend.com",
-          "pathPattern": "^/emails(?:/|$)"
         }
       ],
       "archetype": "crud",
@@ -2185,9 +2319,6 @@
         ]
       },
       "hosts": [
-        {
-          "host": "app.slack.com"
-        },
         {
           "host": "slack.com"
         },

package/dist/inject.cjs

@@ -146,32 +146,61 @@ function installPrismaAdapterShim() {
   if (candidates.length === 0) return;
   Module.__volterPrismaAdapterShimInstalled = true;
   const path = require('path');
-  const originalLoad = Module._load;
-  Module._load = function volterPrismaLoad(request, parent, isMain) {
-    const exports = originalLoad.apply(this, arguments);
-    if (request !== '@prisma/client' || !exports || typeof exports.PrismaClient !== 'function' || exports.PrismaClient.__volterAdapted) return exports;
+  // The package's own entry (its `main`, `default.js`; `index.js` before Prisma 5), patched as it loads (PACKAGE ENTRIES).
+  patchPackageEntry(/[\\/]node_modules[\\/]@prisma[\\/]client[\\/](default|index)\.js$/, (module) => {
+    const exports = module.exports;
+    if (!exports || typeof exports.PrismaClient !== 'function' || exports.PrismaClient.__volterAdapted) return;
     const vendor = candidates.find((candidate) => MAP[candidate] && process.env[packs[candidate].prismaAdapter.urlEnv]);
-    if (!vendor) return exports;
+    if (!vendor) return;
     const facts = packs[vendor].prismaAdapter;
-    // From the requiring module first (a library that constructs the client), then the
-    // application itself, whose dependency the adapter is under pnpm's isolated layout.
-    const from = parent && parent.filename ? path.dirname(parent.filename) : process.cwd();
-    let adapterModule;
-    try {
-      adapterModule = originalLoad.call(this, require.resolve(facts.adapter, { paths: [from, process.cwd()] }), parent, false);
-    } catch {
+    // THE ADAPTER IS FOUND WHERE THE CLIENT IS USED, AT ITS FIRST CONSTRUCTION WITHOUT ONE (review of the World 2209
+    // integration, 75f6a1dd). The entry's own parent is the first module that loaded it. For a copy cached before this
+    // prelude ran, that is not the library that later constructs the client, and an early miss there was final.
+    // At each construction without an adapter, until one is found, these places are asked in turn:
+    // - the directory of each CommonJS module that lists the entry among its children, most recently loaded first, by
+    //   Module._cache's insertion order, with the entry's module.parent last of them. Node's updateChildren records a
+    //   cached require too, so a consumer that requires the client later is found at the next construction;
+    // - the main module's directory and that of process.argv[1];
+    // - the working directory.
+    // An ES module that imports the client is never its parent or one of the cached modules that list it, so an ESM
+    // consumer is reached only through those last places. A found adapter is kept, and said once if a miss was said
+    // before it. A place that missed is not asked again (`missedPlaces`): a new consumer brings a new place, and no
+    // resolve is repeated. A miss is said once, and the construction is left as it was. Module._cache is read at each
+    // construction without an adapter until one is found, a walk of the cache's entries and no file system work.
+    let Adapter;
+    let missSaid = false;
+    const missedPlaces = new Set();
+    const adapterFor = () => {
+      if (Adapter) return Adapter;
+      const consumers = [module.parent, ...Object.values(Module._cache).filter((other) => other && other !== module.parent && Array.isArray(other.children) && other.children.includes(module))]
+        .filter((consumer) => consumer && consumer.filename).reverse();
+      // Each place with the module it is asked for, so the adapter loads as that module's child (Node's bookkeeping
+      // of parent and children only; resolution is by `paths`).
+      const places = new Map();
+      for (const consumer of consumers) if (!places.has(path.dirname(consumer.filename))) places.set(path.dirname(consumer.filename), consumer);
+      if (require.main && require.main.filename && !places.has(path.dirname(require.main.filename))) places.set(path.dirname(require.main.filename), require.main);
+      if (typeof process.argv[1] === 'string' && process.argv[1] && !places.has(path.dirname(path.resolve(process.argv[1])))) places.set(path.dirname(path.resolve(process.argv[1])), null);
+      if (!places.has(process.cwd())) places.set(process.cwd(), null);
+      let reason = `${facts.adapter} is not installed in this application`;
+      for (const [from, consumer] of places) {
+        if (missedPlaces.has(from)) continue;
+        let loaded;
+        try { loaded = Module._load(require.resolve(facts.adapter, { paths: [from] }), consumer, false); }
+        catch { missedPlaces.add(from); continue; }
+        const found = loaded && loaded[facts.export];
+        if (typeof found === 'function') {
+          Adapter = found;
+          if (missSaid) process.stderr.write(`[twin-inject] ${vendor}: ${facts.adapter} found from ${from}; a Prisma client constructed without an adapter from now on gets it\n`);
+          return Adapter;
+        }
+        missedPlaces.add(from);
+        reason = `${facts.adapter} exports no ${facts.export}`;
+      }
       // Left as it was, said once: on the client engine Prisma refuses the construction itself;
       // on the library engine the client reaches the twin over the vendor's own wire.
-      process.stderr.write(`[twin-inject] ${vendor}: ${facts.adapter} is not installed in this application, so a Prisma client constructed without an adapter is left as it was\n`);
-      exports.PrismaClient.__volterAdapted = true;
-      return exports;
-    }
-    const Adapter = adapterModule && adapterModule[facts.export];
-    if (typeof Adapter !== 'function') {
-      process.stderr.write(`[twin-inject] ${vendor}: ${facts.adapter} exports no ${facts.export}; a Prisma client constructed without an adapter is left as it was\n`);
-      exports.PrismaClient.__volterAdapted = true;
-      return exports;
-    }
+      if (!missSaid) { missSaid = true; process.stderr.write(`[twin-inject] ${vendor}: ${reason}, so a Prisma client constructed without an adapter is left as it was until it is found\n`); }
+      return undefined;
+    };
     const Base = exports.PrismaClient;
     class PrismaClient extends Base {
       constructor(options) {
@@ -180,16 +209,18 @@ function installPrismaAdapterShim() {
         // decision. The URL is the application's where it names one (its host is twinned by the
         // injector's own host rules), else the endpoint template's variable.
         if ('adapter' in given) { super(given); return; }
+        const Found = adapterFor();
+        // Left as it was: Prisma is given exactly what the application passed (`new PrismaClient()` is no options).
+        if (!Found) { super(...arguments); return; }
         const named = given.datasources && typeof given.datasources === 'object'
           ? Object.values(given.datasources).map((source) => source && source.url).find((value) => typeof value === 'string') : undefined;
         const url = given.datasourceUrl || named || process.env[facts.urlEnv];
-        super({ ...given, adapter: new Adapter({ url, fetch: (...args) => globalThis.fetch(...args) }) });
+        super({ ...given, adapter: new Found({ url, fetch: (...args) => globalThis.fetch(...args) }) });
       }
     }
     PrismaClient.__volterAdapted = true;
     exports.PrismaClient = PrismaClient;
-    return exports;
-  };
+  });
 }
 
 // The exact inverse of readMap's env lookup: which vendor (if any) would the injector read
@@ -647,50 +678,77 @@ function routedTwin(url) {
 }
 // Imported Undici APIs may hold a dispatcher obtained before the global view was installed.
 // Rewrite their public HTTP doors as well; an independent connector still faces the socket guards.
-let UNDICI_LOAD = null;
+// PACKAGE ENTRIES, TAKEN WHEN THEY LOAD (S2): the preludes that act on one package (undici, @prisma/client, miniflare)
+// wrapped Module._load and ran on every load of the process to compare one name (LibreChat's server: 20,228 loads,
+// ~20 ms in the tab, none of it in native's path), and a wrapped Module._load kept the tab's engine on its slower
+// replaced-load route for every require. Each is now a patch of the package's entry module, made when that file is
+// loaded (Module._extensions['.js'], once per new module): the entry is loaded once per copy (every version, every
+// root, late or early) and cached, so the exports the patch leaves are what every later require of that copy is
+// answered, and an `import` of it loads it the same way. A copy loaded before this prelude ran is patched where it is
+// cached: its exports object is patched in place, so later requires and imports, and a module that holds that exports
+// object, see the patch; only a binding taken from it before the prelude ran (a destructured PrismaClient, an ES
+// module's namespace already linked) keeps the original. Known limits: a '.js' handler installed later that does not call the one it replaced hides the entries
+// loaded through it; an entry outside a node_modules directory (a linked checkout of the package) is not recognized.
+const ENTRY_PATCHES = [];
+let ENTRY_LOAD = null;
+function patchPackageEntry(pattern, patch) {
+  ENTRY_PATCHES.push({ pattern, patch });
+  for (const [filename, module] of Object.entries(Module._cache)) {
+    if (pattern.test(filename) && module && module.loaded) patch(module, filename);
+  }
+  if (ENTRY_LOAD) return;
+  const original = ENTRY_LOAD = Module._extensions['.js'];
+  Module._extensions['.js'] = function volterPackageEntry(module, filename) {
+    const result = original.apply(this, arguments);
+    for (const entry of ENTRY_PATCHES) if (entry.pattern.test(filename)) entry.patch(module, filename);
+    return result;
+  };
+}
+
+let UNDICI_ROUTED = false;
 function routeImportedUndici() {
-  if (UNDICI_LOAD) return;
-  const original = UNDICI_LOAD = Module._load;
-  const seen = new WeakMap();
-  Module._load = function volterUndiciLoad(request, parent, isMain) {
-    const exports = original.apply(this, arguments);
-    if (request !== 'undici' || !exports || typeof exports.request !== 'function') return exports;
-    if (seen.has(exports)) return seen.get(exports);
-    const view = Object.assign({}, exports);
-    view.fetch = function routedUndiciFetch(input, init) {
-      if (!installed) return exports.fetch(input, init);
-      let url; try { url = new URL(typeof input === 'object' && input?.url ? input.url : String(input)); } catch {}
-      const twin = routedTwin(url);
-      // Local control planes may use their own Request class and dispatcher. Preserve both;
-      // connections still pass the socket guards, and claimed vendor hops still enter routing.
-      if (url && isLocalOrPrivateHost(url.hostname) && (!twin || twin.vendor === 'app')) return exports.fetch(input, init);
-      if (input && typeof input === 'object' && typeof input.url === 'string' && !(input instanceof globalThis.Request)) {
-        const options = {};
-        for (const name of ['method', 'signal', 'redirect', 'cache', 'credentials', 'integrity', 'keepalive', 'referrer', 'referrerPolicy']) {
-          if (input[name] !== undefined) options[name] = input[name];
-        }
-        options.headers = Array.from(input.headers);
-        if (input.body !== null && input.body !== undefined) { options.body = input.body; options.duplex = 'half'; }
-        return globalThis.fetch(input.url, { ...options, ...init });
+  if (UNDICI_ROUTED) return;
+  UNDICI_ROUTED = true;
+  patchPackageEntry(/[\\/]node_modules[\\/]undici[\\/]index\.js$/, (module) => {
+    if (module.exports && typeof module.exports.request === 'function' && !ROUTED_UNDICI.has(module.exports)) module.exports = routedUndici(module.exports);
+  });
+}
+const ROUTED_UNDICI = new WeakSet();
+function routedUndici(exports) {
+  const view = Object.assign({}, exports);
+  view.fetch = function routedUndiciFetch(input, init) {
+    if (!installed) return exports.fetch(input, init);
+    let url; try { url = new URL(typeof input === 'object' && input?.url ? input.url : String(input)); } catch {}
+    const twin = routedTwin(url);
+    // Local control planes may use their own Request class and dispatcher. Preserve both;
+    // connections still pass the socket guards, and claimed vendor hops still enter routing.
+    if (url && isLocalOrPrivateHost(url.hostname) && (!twin || twin.vendor === 'app')) return exports.fetch(input, init);
+    if (input && typeof input === 'object' && typeof input.url === 'string' && !(input instanceof globalThis.Request)) {
+      const options = {};
+      for (const name of ['method', 'signal', 'redirect', 'cache', 'credentials', 'integrity', 'keepalive', 'referrer', 'referrerPolicy']) {
+        if (input[name] !== undefined) options[name] = input[name];
       }
-      return globalThis.fetch(input, init);
-    };
-    view.request = function routedUndiciRequest(input, options, callback) {
-      if (!installed) return exports.request.apply(exports, arguments);
-      const opts = typeof options === 'function' ? {} : options ?? {};
-      let url; try { url = new URL(String(input)); if (opts.path !== undefined) url = new URL(url.origin + String(opts.path)); } catch {}
-      const twin = routedTwin(url);
-      if (!twin || twin.vendor === 'app') return exports.request.apply(exports, arguments);
-      const headers = undiciHeaderObject(opts.headers);
-      headers.host = url.host; headers['x-volter-twin-original-host'] = url.host;
-      const key = twinsKey(); if (key) headers['x-twins-key'] = key;
-      const target = twin.origin.replace(/\/$/, '') + url.pathname + url.search;
-      const { path: _path, ...requestOptions } = opts; // target already carries the effective path and endpoint prefix
-      return exports.request(target, { ...requestOptions, headers, maxRedirections: 0 }, typeof options === 'function' ? options : callback);
-    };
-    seen.set(exports, view);
-    return view;
+      options.headers = Array.from(input.headers);
+      if (input.body !== null && input.body !== undefined) { options.body = input.body; options.duplex = 'half'; }
+      return globalThis.fetch(input.url, { ...options, ...init });
+    }
+    return globalThis.fetch(input, init);
+  };
+  view.request = function routedUndiciRequest(input, options, callback) {
+    if (!installed) return exports.request.apply(exports, arguments);
+    const opts = typeof options === 'function' ? {} : options ?? {};
+    let url; try { url = new URL(String(input)); if (opts.path !== undefined) url = new URL(url.origin + String(opts.path)); } catch {}
+    const twin = routedTwin(url);
+    if (!twin || twin.vendor === 'app') return exports.request.apply(exports, arguments);
+    const headers = undiciHeaderObject(opts.headers);
+    headers.host = url.host; headers['x-volter-twin-original-host'] = url.host;
+    const key = twinsKey(); if (key) headers['x-twins-key'] = key;
+    const target = twin.origin.replace(/\/$/, '') + url.pathname + url.search;
+    const { path: _path, ...requestOptions } = opts; // target already carries the effective path and endpoint prefix
+    return exports.request(target, { ...requestOptions, headers, maxRedirections: 0 }, typeof options === 'function' ? options : callback);
   };
+  ROUTED_UNDICI.add(view);
+  return view;
 }
 function unkeyUndiciDispatches() {
   if (!ORIGINAL_DEFINE_PROPERTY) return;
@@ -1712,12 +1770,25 @@ function installWorldTime() {
   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),
+  // and Date.prototype is the machine's; only now() and argument-less construction read the World's time. A bound
+  // function, not a Proxy: every `new Date(x)` of the app (a driver decoding dates) ran the Proxy's construct trap,
+  // ~15 ms of self time on LibreChat's server start in the tab (S2). Bound, so Function.prototype.toString of Date
+  // says "function () { [native code] }", as the Proxy's did; a bound function constructs its target with the target
+  // as new.target, and a subclass's own new.target passes through. Its prototype is the machine's; its own keys are
+  // the machine's Date's (length, name, prototype, now, parse, UTC), `now` the World's.
+  const worldDate = function Date(...args) {
     // called as a function, Date() answers the current time's string, as the machine's does
-    apply: () => new MachineDate(worldMs()).toString(),
-  });
+    if (new.target === undefined) return new MachineDate(worldMs()).toString();
+    return Reflect.construct(MachineDate, args.length ? args : [worldMs()], new.target === worldDate ? MachineDate : new.target);
+  };
+  worldDate.prototype = MachineDate.prototype;
+  const WorldDate = worldDate.bind(undefined);
+  Object.defineProperty(WorldDate, 'name', { value: 'Date', configurable: true });
+  Object.defineProperty(WorldDate, 'length', { value: MachineDate.length, configurable: true });
+  Object.defineProperty(WorldDate, 'prototype', { value: MachineDate.prototype });
+  for (const [key, value] of [['now', worldMs], ['parse', MachineDate.parse], ['UTC', MachineDate.UTC]]) {
+    Object.defineProperty(WorldDate, key, { value, writable: true, configurable: true, enumerable: false });
+  }
   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 });
@@ -1780,17 +1851,12 @@ function installMiniflareOutbound() {
     };
     return Array.isArray(options.workers) ? { ...options, workers: options.workers.map(worker) } : worker(options);
   };
-  const originalLoad = Module._load;
-  const seen = new WeakMap();
-  Module._load = function volterMiniflareLoad(request, parent) {
-    const exports = originalLoad.apply(this, arguments);
-    if (request !== 'miniflare' || !exports || typeof exports.Miniflare !== 'function' || exports.Miniflare.__volterRouted) return exports;
-    if (seen.has(exports)) return seen.get(exports);
-    if (!outbound) {
-      let at = null;
-      try { at = Module._resolveFilename(request, parent); } catch { at = null; }
-      outbound = outboundFor(at, exports.fetch);
-    }
+  // The package's own entry (miniflare's `main`, dist/src/index.js), patched as it loads (PACKAGE ENTRIES).
+  patchPackageEntry(/[\\/]node_modules[\\/]miniflare[\\/]dist[\\/]src[\\/]index\.js$/, (module, filename) => {
+    const exports = module.exports;
+    if (!exports || typeof exports.Miniflare !== 'function' || exports.Miniflare.__volterRouted) return;
+    // the entry is the file `require('miniflare')` resolved to: its undici is the one beside it
+    if (!outbound) outbound = outboundFor(filename, exports.fetch);
     const Original = exports.Miniflare;
     class Miniflare extends Original {
       constructor(options) { super(routed(options)); }
@@ -1799,10 +1865,8 @@ function installMiniflareOutbound() {
     Miniflare.__volterRouted = true;
     // miniflare's build exports `Miniflare` as a getter that can be neither assigned nor redefined: its importer is given
     // a view of the module whose `Miniflare` is this one, the same view each time it is required.
-    const view = new Proxy(exports, { get: (target, key, receiver) => (key === 'Miniflare' ? Miniflare : Reflect.get(target, key, receiver)) });
-    seen.set(exports, view);
-    return view;
-  };
+    module.exports = new Proxy(exports, { get: (target, key, receiver) => (key === 'Miniflare' ? Miniflare : Reflect.get(target, key, receiver)) });
+  });
 }
 
 // Auto-install as a preload (`--require`); strict refusal also applies without twin URLs.

package/dist/src/actions.d.ts

@@ -141,6 +141,21 @@ export declare function appendActionOccurrence(base: TwinAction, root?: string):
     appended: boolean;
     placeholder?: true;
 };
+/**
+ * Append several writes of ONE service as occurrences, in order, under one projection + actions lock and as one store
+ * append: each lands with the id, ordinal and correlation `appendActionOccurrence` would give it called once per write
+ * in the same order (a write's ordinal counts the batch's earlier writes as taken). A Redis run's flush made one
+ * append per changed member and key, each taking the history, projection and actions locks and appending alone, one
+ * after another under the twin's single command queue (S2 R19: Twenty's queue scripts spent up to 2.1 s of a 2 s
+ * window in flush while 38 commands waited). A write carrying preconditions is not taken here: each is checked against
+ * the state the earlier ones made, which only the one-at-a-time path sees. While a placeholder pull is open a write
+ * lands as observed events, as `appendActionOccurrence`'s does.
+ */
+export declare function appendActionOccurrences(bases: readonly TwinAction[], root?: string): Array<{
+    action: TwinAction;
+    appended: boolean;
+    placeholder?: true;
+}>;
 /** Occurrence 0 IS the base id — so nothing that exists today changes shape. The appender owns
  *  this math; a caller passing an already-ordinalled id would stack them (`…#1#1`). */
 export declare function occurrenceId(base: string, ordinal: number): string;