@volter/world-core 3.0.154 → 3.0.156

package/dist/src/xml.d.ts

@@ -0,0 +1,30 @@
+export type XmlElement = {
+    kind: 'element';
+    name: string;
+    attributes: Record<string, string>;
+    content: XmlContent[];
+};
+export type XmlText = {
+    kind: 'text' | 'cdata' | 'comment';
+    value: string;
+};
+export type XmlInstruction = {
+    kind: 'processing-instruction';
+    target: string;
+    value: string;
+};
+export type XmlContent = XmlElement | XmlText | XmlInstruction;
+export type XmlDocument = {
+    root: XmlElement;
+    prologue: Array<XmlText | XmlInstruction>;
+    epilogue: Array<XmlText | XmlInstruction>;
+};
+export declare class XmlDocumentError extends Error {
+    readonly code: 'parser-unavailable' | 'unsupported-declaration' | 'malformed-document' | 'parsing-limit';
+    constructor(code: 'parser-unavailable' | 'unsupported-declaration' | 'malformed-document' | 'parsing-limit');
+}
+/** No I/O, globals, vendor names, defaults or recovery. Importing this module does not load the grammar.
+ * The XML declaration is a processing instruction in the prologue. A leading BOM is refused.
+ * Raw DOCTYPE/ENTITY markers refuse even inside comments or CDATA: this conservative preflight is linear.
+ */
+export declare function parseDocument(source: string): Promise<XmlDocument>;

package/dist/src/xml.js

@@ -0,0 +1,74 @@
+export class XmlDocumentError extends Error {
+    code;
+    constructor(code) {
+        super(code === 'parser-unavailable' ? 'Strict XML parser @xmldom/xmldom 0.9.12 is unavailable'
+            : code === 'unsupported-declaration' ? 'DTD and entity declarations are unsupported'
+                : code === 'parsing-limit' ? 'XML document exceeds the supported parsing limits'
+                    : 'XML document is not well formed');
+        this.code = code;
+        this.name = 'XmlDocumentError';
+    }
+}
+let grammar;
+function loadGrammar() {
+    return grammar ??= import('@xmldom/xmldom').catch(() => { grammar = undefined; throw new XmlDocumentError('parser-unavailable'); });
+}
+/** No I/O, globals, vendor names, defaults or recovery. Importing this module does not load the grammar.
+ * The XML declaration is a processing instruction in the prologue. A leading BOM is refused.
+ * Raw DOCTYPE/ENTITY markers refuse even inside comments or CDATA: this conservative preflight is linear.
+ */
+export async function parseDocument(source) {
+    if (typeof source !== 'string' || source.charCodeAt(0) === 0xfeff)
+        throw new XmlDocumentError('malformed-document');
+    if (source.indexOf('<!DOCTYPE') !== -1 || source.indexOf('<!ENTITY') !== -1)
+        throw new XmlDocumentError('unsupported-declaration');
+    const { DOMParser } = await loadGrammar();
+    try {
+        const document = new DOMParser({ onError: () => { throw new XmlDocumentError('malformed-document'); } }).parseFromString(source, 'application/xml');
+        const convert = (node) => {
+            if (node.nodeType === 1) {
+                const element = node;
+                const attributes = Object.create(null);
+                for (const attr of Array.from(element.attributes))
+                    attributes[attr.name] = attr.value;
+                return { kind: 'element', name: element.tagName, attributes, content: [] };
+            }
+            if (node.nodeType === 3 || node.nodeType === 4 || node.nodeType === 8)
+                return { kind: node.nodeType === 3 ? 'text' : node.nodeType === 4 ? 'cdata' : 'comment', value: node.nodeValue ?? '' };
+            if (node.nodeType === 7)
+                return { kind: 'processing-instruction', target: node.nodeName, value: node.nodeValue ?? '' };
+            throw new XmlDocumentError(node.nodeType === 10 ? 'unsupported-declaration' : 'malformed-document');
+        };
+        const pending = [];
+        const one = (source) => {
+            const target = convert(source);
+            if (target.kind === 'element')
+                pending.push({ source, target });
+            return target;
+        };
+        const nodes = Array.from(document.childNodes).map(one);
+        while (pending.length) {
+            const { source, target } = pending.pop();
+            for (const child of Array.from(source.childNodes))
+                target.content.push(one(child));
+        }
+        const roots = nodes.filter((node) => node.kind === 'element');
+        if (roots.length !== 1)
+            throw new XmlDocumentError('malformed-document');
+        const root = roots[0], index = nodes.indexOf(root);
+        const outside = (list) => list.map(node => {
+            if (node.kind === 'element' || node.kind === 'cdata' || (node.kind === 'text' && node.value.trim()))
+                throw new XmlDocumentError('malformed-document');
+            return node;
+        });
+        return { root, prologue: outside(nodes.slice(0, index)), epilogue: outside(nodes.slice(index + 1)) };
+    }
+    catch (error) {
+        if (error instanceof XmlDocumentError)
+            throw error;
+        if (error instanceof RangeError)
+            throw new XmlDocumentError('parsing-limit');
+        // The grammar's diagnostics can contain source bytes. Expose a fixed error, keeping credentials out of reports.
+        throw new XmlDocumentError('malformed-document');
+    }
+}

package/generated/pack-facts.json

@@ -328,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": [
@@ -1011,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": [
@@ -1514,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": [

package/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/world-core",
-  "version": "3.0.154",
+  "version": "3.0.156",
   "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",
@@ -128,9 +128,25 @@
       "types": "./dist/src/live/index.d.ts",
       "default": "./dist/src/live/index.js"
     },
+    "./mongodb": {
+      "types": "./dist/src/mongodb/index.d.ts",
+      "default": "./dist/src/mongodb/index.js"
+    },
     "./clickhouse": {
       "types": "./dist/src/clickhouse/index.d.ts",
       "default": "./dist/src/clickhouse/index.js"
+    },
+    "./runtime-state": {
+      "types": "./dist/src/runtime-state.d.ts",
+      "default": "./dist/src/runtime-state.js"
+    },
+    "./browser-state": {
+      "types": "./dist/src/browser-state.d.ts",
+      "default": "./dist/src/browser-state.js"
+    },
+    "./managed-original-inputs": {
+      "types": "./dist/src/managed-original-inputs.d.ts",
+      "default": "./dist/src/managed-original-inputs.js"
     }
   },
   "scripts": {
@@ -156,5 +172,8 @@
   },
   "engines": {
     "node": ">=22.3"
+  },
+  "optionalDependencies": {
+    "@xmldom/xmldom": "0.9.12"
   }
 }