@volter/world-core 3.0.156 → 3.0.158

package/attach.cjs

@@ -35,6 +35,8 @@ if (ref) {
       throw new Error(`[twin-attach] could not fetch the world manifest from ${url}: ${(probe.stderr || '').trim()}`);
     }
     const manifest = JSON.parse(probe.stdout);
+    if (manifest === null || typeof manifest !== 'object' || Array.isArray(manifest)) throw new Error('[twin-attach] remote world returned no manifest');
+    if (Object.hasOwn(manifest, 'requiredCredentials')) throw new Error('[twin-attach] required credential remote transport is unsupported; refusing before bridges or injection');
     const { worldAttachmentNetworkEnv, worldStrictEgress } = require('./network-policy.cjs');
     Object.assign(process.env, worldAttachmentNetworkEnv(ref, manifest.network, process.env, worldStrictEgress(manifest.env ?? {})));
     // a served World's twins as loopback listeners that add its key (./http-bridge.cjs), so a client with its own HTTP

package/capability-decision.cjs

@@ -4,7 +4,7 @@
 // scoped proxy, a tab's relay, a native image run's Seatbelt profile) enforces this answer and decides nothing itself.
 // Pure: no I/O, no environment and nothing at import. What only the substrate can observe (the twin route, the vendors
 // sharing a host, which loopback ports are the World's doors or the run's own listeners) arrives as `facts`.
-const { allowsWorldNetworkEgress, isWorldInternalHost, worldNetworkNeedsPathInspection, worldNetworkUsesPassthrough } = require('./network-policy.cjs');
+const { allowsWorldNetworkEgress, explicitlyGrantsWorldNetworkEgress, isWorldInternalHost, worldNetworkNeedsPathInspection, worldNetworkUsesPassthrough } = require('./network-policy.cjs');
 
 /** The declaration of a guest with no declaration format: an ordinary host process, which can reach what the host can.
  *  Its own loopback is what it observably opened (`facts.ownListener`). A substrate whose guest can declare never uses it. */
@@ -135,7 +135,8 @@ function unlisted(url, target, method, { declaration, grant = {} }) {
   if (grant.strict === true) return refuse(capability, target, 'grant', 'sealed', `this sandbox refuses untwinned host ${url.hostname}`, declaration);
   if (grant.unreadable) return refuse(capability, target, 'grant', 'policy-unreadable', `the World network policy is unreadable (${grant.unreadable}); refusing ${url.hostname}`, declaration);
   if (grant.policy && !allowsWorldNetworkEgress(grant.policy, url, method ?? 'GET')) {
-    return refuse(capability, target, 'grant', 'not-granted', `the World network policy does not allow ${String(method ?? 'GET').toUpperCase()} ${url.origin}`, declaration);
+    // a tunnel (CONNECT) shows no method: the refusal names what was asked, never a method nobody sent
+    return refuse(capability, target, 'grant', 'not-granted', `the World network policy does not allow ${method ? `${String(method).toUpperCase()} ` : ''}${url.origin}`, declaration);
   }
   return null;
 }
@@ -254,9 +255,10 @@ function decideRead(request, { declaration, facts = {} }) {
   return refuse(capability, path, 'declaration', 'read-undeclared', `in Docker this container cannot read ${path}: it sees its own filesystem, the World's files and its declared mounts; declare a mount`, declaration);
 }
 
-/** Whether the World's build-phase grant lists `url` itself, which then wins over a twin of its host. */
+/** Whether the World's build-phase grant lists `url` itself, which then wins over a twin of its host. The unlisted
+ *  public build reads do not: on a twinned host the twin answers them. */
 function publicBuildGrant(grant, url) {
-  return grant.strict !== true && !!grant.policy && grant.policy.phase === 'build' && allowsWorldNetworkEgress(grant.policy, url);
+  return grant.strict !== true && !!grant.policy && grant.policy.phase === 'build' && explicitlyGrantsWorldNetworkEgress(grant.policy, url);
 }
 
 /** A path the guest writes as its data (a `VOLUME`). Declared, it passes run-scoped: writable for the run, not outliving

package/dist/attach.cjs

@@ -35,6 +35,8 @@ if (ref) {
       throw new Error(`[twin-attach] could not fetch the world manifest from ${url}: ${(probe.stderr || '').trim()}`);
     }
     const manifest = JSON.parse(probe.stdout);
+    if (manifest === null || typeof manifest !== 'object' || Array.isArray(manifest)) throw new Error('[twin-attach] remote world returned no manifest');
+    if (Object.hasOwn(manifest, 'requiredCredentials')) throw new Error('[twin-attach] required credential remote transport is unsupported; refusing before bridges or injection');
     const { worldAttachmentNetworkEnv, worldStrictEgress } = require('./network-policy.cjs');
     Object.assign(process.env, worldAttachmentNetworkEnv(ref, manifest.network, process.env, worldStrictEgress(manifest.env ?? {})));
     // a served World's twins as loopback listeners that add its key (./http-bridge.cjs), so a client with its own HTTP

package/dist/capability-decision.cjs

@@ -4,7 +4,7 @@
 // scoped proxy, a tab's relay, a native image run's Seatbelt profile) enforces this answer and decides nothing itself.
 // Pure: no I/O, no environment and nothing at import. What only the substrate can observe (the twin route, the vendors
 // sharing a host, which loopback ports are the World's doors or the run's own listeners) arrives as `facts`.
-const { allowsWorldNetworkEgress, isWorldInternalHost, worldNetworkNeedsPathInspection, worldNetworkUsesPassthrough } = require('./network-policy.cjs');
+const { allowsWorldNetworkEgress, explicitlyGrantsWorldNetworkEgress, isWorldInternalHost, worldNetworkNeedsPathInspection, worldNetworkUsesPassthrough } = require('./network-policy.cjs');
 
 /** The declaration of a guest with no declaration format: an ordinary host process, which can reach what the host can.
  *  Its own loopback is what it observably opened (`facts.ownListener`). A substrate whose guest can declare never uses it. */
@@ -135,7 +135,8 @@ function unlisted(url, target, method, { declaration, grant = {} }) {
   if (grant.strict === true) return refuse(capability, target, 'grant', 'sealed', `this sandbox refuses untwinned host ${url.hostname}`, declaration);
   if (grant.unreadable) return refuse(capability, target, 'grant', 'policy-unreadable', `the World network policy is unreadable (${grant.unreadable}); refusing ${url.hostname}`, declaration);
   if (grant.policy && !allowsWorldNetworkEgress(grant.policy, url, method ?? 'GET')) {
-    return refuse(capability, target, 'grant', 'not-granted', `the World network policy does not allow ${String(method ?? 'GET').toUpperCase()} ${url.origin}`, declaration);
+    // a tunnel (CONNECT) shows no method: the refusal names what was asked, never a method nobody sent
+    return refuse(capability, target, 'grant', 'not-granted', `the World network policy does not allow ${method ? `${String(method).toUpperCase()} ` : ''}${url.origin}`, declaration);
   }
   return null;
 }
@@ -254,9 +255,10 @@ function decideRead(request, { declaration, facts = {} }) {
   return refuse(capability, path, 'declaration', 'read-undeclared', `in Docker this container cannot read ${path}: it sees its own filesystem, the World's files and its declared mounts; declare a mount`, declaration);
 }
 
-/** Whether the World's build-phase grant lists `url` itself, which then wins over a twin of its host. */
+/** Whether the World's build-phase grant lists `url` itself, which then wins over a twin of its host. The unlisted
+ *  public build reads do not: on a twinned host the twin answers them. */
 function publicBuildGrant(grant, url) {
-  return grant.strict !== true && !!grant.policy && grant.policy.phase === 'build' && allowsWorldNetworkEgress(grant.policy, url);
+  return grant.strict !== true && !!grant.policy && grant.policy.phase === 'build' && explicitlyGrantsWorldNetworkEgress(grant.policy, url);
 }
 
 /** A path the guest writes as its data (a `VOLUME`). Declared, it passes run-scoped: writable for the run, not outliving

package/dist/generated/pack-facts.json

@@ -221,6 +221,50 @@
       },
       "serveExport": "createAxiomTwinServer"
     },
+    "bitly": {
+      "adoption": {
+        "sdks": [],
+        "envStems": [
+          "BITLY",
+          "BUFFER_BITLY"
+        ]
+      },
+      "hosts": [
+        {
+          "host": "api-ssl.bitly.com"
+        },
+        {
+          "host": "bitly.com",
+          "pathPattern": "^/oauth/authorize/?$"
+        }
+      ],
+      "archetype": "crud",
+      "protocol": {
+        "declared": "3",
+        "major": 3,
+        "standing": "current"
+      },
+      "transport": "rest",
+      "resources": [
+        "group",
+        "bitlink"
+      ],
+      "endpointEnvNone": "Dub uses literal vendor URLs and native fetch; the World routes them by host.",
+      "credentialDoor": {
+        "path": "/_twin/signup",
+        "body": {
+          "email": "publisher@example.test",
+          "password": "throwaway-bitly-password",
+          "login": "publisher"
+        },
+        "fill": {
+          "BITLY_CLIENT_ID": "client_id",
+          "BITLY_CLIENT_SECRET": "client_secret",
+          "BUFFER_BITLY_API_KEY": "access_token"
+        }
+      },
+      "serveExport": "createBitlyTwinServer"
+    },
     "cerebras": {
       "adoption": {
         "sdks": [
@@ -270,6 +314,9 @@
         {
           "host": "api.clerk.com"
         },
+        {
+          "host": "dashboard.clerk.com"
+        },
         {
           "suffix": ".clerk.accounts.dev"
         },
@@ -594,7 +641,7 @@
       },
       "transport": "rest",
       "resources": [],
-      "endpointEnvNone": "Postiz calls https://api.deepgram.com/v1/listen; the World claims the host",
+      "endpointEnvNone": "No scanned application calls Deepgram; the World claims api.deepgram.com",
       "serveExport": "createDeepgramTwinServer"
     },
     "discord": {
@@ -842,7 +889,7 @@
       },
       "transport": "rest",
       "resources": [],
-      "endpointEnvNone": "Postiz calls https://fal.run/fal-ai/<model>; the World claims the hosts",
+      "endpointEnvNone": "the customer life calls https://fal.run/fal-ai/<model>; the World claims the hosts",
       "credentialDoor": {
         "path": "/_twin/app-credentials",
         "body": {},
@@ -1012,7 +1059,7 @@
         },
         {
           "host": "github.com",
-          "pathPattern": "^/login|^/session|^/settings/|^/organizations/|^/apps/|^/[^/]+/[^/]+/(?:info/refs|git-upload-pack|git-receive-pack)$|^/[^/]+/[^/]+\\.git/"
+          "pathPattern": "^/login|^/session|^/settings/|^/organizations/|^/apps/|^/[^/]+/[^/]+/(?:info/refs|git-upload-pack|git-receive-pack)$|^/[^/]+/[^/]+\\.git/|^/[^/]+/[^/]+/?$|^/[^/]+/[^/]+/(?:issues|pulls?|blob|raw|tree|commits?|compare)(?:/|$)"
         }
       ],
       "archetype": "crud",
@@ -1088,7 +1135,7 @@
         },
         {
           "host": "fonts.googleapis.com",
-          "pathPattern": "^/css$"
+          "pathPattern": "^/css2?$"
         },
         {
           "host": "fonts.gstatic.com",
@@ -1417,8 +1464,7 @@
           "host": "api.linear.app"
         },
         {
-          "host": "linear.app",
-          "pathPattern": "^/oauth/"
+          "host": "linear.app"
         }
       ],
       "archetype": "crud",
@@ -1438,7 +1484,7 @@
         "comment",
         "issue_label"
       ],
-      "endpointEnvNone": "Linear uses api.linear.app/graphql and linear.app/oauth/authorize; the World claims the documented hosts",
+      "endpointEnvNone": "Linear uses api.linear.app/graphql and linear.app for its workspace and OAuth authorize page; the World claims those hosts",
       "credentialDoor": {
         "path": "/_twin/local-credentials",
         "body": {},
@@ -2048,6 +2094,10 @@
           "host": "reddit.com",
           "demandPathPattern": "^/api/"
         },
+        {
+          "host": "old.reddit.com",
+          "demandPathPattern": "^/api/"
+        },
         {
           "host": "reddit-uploaded-media.s3-accelerate.amazonaws.com"
         },
@@ -2163,6 +2213,10 @@
         },
         {
           "host": "inbound-cdn.resend.com"
+        },
+        {
+          "host": "resend.com",
+          "pathPattern": "^/emails(?:/|$)"
         }
       ],
       "archetype": "crud",
@@ -2319,6 +2373,9 @@
         ]
       },
       "hosts": [
+        {
+          "host": "app.slack.com"
+        },
         {
           "host": "slack.com"
         },
@@ -2697,7 +2754,7 @@
         "publish",
         "video"
       ],
-      "endpointEnvNone": "Postiz calls open.tiktokapis.com and sends people to www.tiktok.com; the World claims the hosts",
+      "endpointEnvNone": "an app calls open.tiktokapis.com and sends people to www.tiktok.com; the World claims the hosts",
       "credentialDoor": {
         "path": "/_twin/app-credentials",
         "body": {},
@@ -3280,6 +3337,18 @@
         "_code_challenge",
         "upload"
       ],
+      "credentialDoor": {
+        "path": "/_twin/app-credentials",
+        "body": {},
+        "fill": {
+          "TWITTER_API_KEY": "consumer_key",
+          "TWITTER_API_SECRET": "consumer_secret",
+          "TWITTER_ACCESS_TOKEN": "access_token",
+          "TWITTER_ACCESS_SECRET": "access_token_secret",
+          "TWITTER_CLIENT_ID": "client_id",
+          "TWITTER_CLIENT_SECRET": "client_secret"
+        }
+      },
       "serveExport": "createXTwinServer"
     },
     "xai": {

package/dist/network-policy.cjs

@@ -140,6 +140,16 @@ function allowsWorldNetworkEgress(policy, value, method = 'GET') {
   return granted(policy.egress, to) || (policy.phase === 'build' && policy.publicReads === true && PUBLIC_BUILD_READS.includes(to.url.origin));
 }
 
+/** Whether the config grants this request by name (`egress` for a read, `writes` for any method): the grant that takes a
+ *  build World's request past a twinned host's twin to its real origin. The unlisted public build reads are not one:
+ *  on a twinned host the twin answers them (architecture, "Reads are granted generously, writes narrowly"). */
+function explicitlyGrantsWorldNetworkEgress(policy, value, method = 'GET') {
+  const to = destination(value, true);
+  if (!to) return false;
+  if (granted(policy.writes ?? [], to)) return true;
+  return READ_METHODS.includes(String(method).toUpperCase()) && granted(policy.egress, to);
+}
+
 function worldNetworkUsesPassthrough(policy, value) {
   const to = destination(value, true);
   if (!to || policy.phase !== 'build') return false;
@@ -222,4 +232,4 @@ function worldEgressRefusal(value, env = process.env, method = 'GET') {
   return answer.outcome === 'refuse' ? `${answer.reason} (${refusalSide(answer)})` : null;
 }
 
-module.exports = { worldAttachmentNetworkEnv, worldStrictEgress, worldGrantFromEnv, PUBLIC_BUILD_READS, READ_METHODS, intersectWorldNetwork, worldNetworkNeedsPathInspection, worldNetworkUsesPassthrough, isWorldInternalHost, worldEgressRefusal, WORLD_NETWORK_POLICY_ENV, normalizeWorldNetwork, createWorldNetworkPolicy, parseWorldNetworkPolicy, worldNetworkPolicyFromEnv, allowsWorldNetworkEgress };
+module.exports = { worldAttachmentNetworkEnv, worldStrictEgress, worldGrantFromEnv, PUBLIC_BUILD_READS, READ_METHODS, intersectWorldNetwork, worldNetworkNeedsPathInspection, worldNetworkUsesPassthrough, isWorldInternalHost, worldEgressRefusal, WORLD_NETWORK_POLICY_ENV, normalizeWorldNetwork, createWorldNetworkPolicy, parseWorldNetworkPolicy, worldNetworkPolicyFromEnv, allowsWorldNetworkEgress, explicitlyGrantsWorldNetworkEgress };

package/dist/network-policy.d.cts

@@ -10,6 +10,7 @@ export function worldNetworkPolicyFromEnv(env: Readonly<Record<string, string |
 export const READ_METHODS: readonly string[];
 export const PUBLIC_BUILD_READS: readonly string[];
 export function allowsWorldNetworkEgress(policy: WorldNetworkPolicy, value: string | URL, method?: string): boolean;
+export function explicitlyGrantsWorldNetworkEgress(policy: WorldNetworkPolicy, value: string | URL, method?: string): boolean;
 export function isWorldInternalHost(hostname: string): boolean;
 export function worldEgressRefusal(value: string | URL, env?: Readonly<Record<string, string | undefined>>, method?: string): string | null;
 export function worldNetworkNeedsPathInspection(policy: WorldNetworkPolicy, value: string | URL): boolean;

package/dist/pack-facts.d.cts

@@ -0,0 +1,3 @@
+export type PackFacts = { packs: Record<string, Record<string, unknown>>; installed: string[]; [key: string]: unknown };
+export function packFacts(): PackFacts;
+export function extendPackFacts(files: string[] | undefined): PackFacts;

package/dist/required-credential-transport.cjs

@@ -0,0 +1,29 @@
+// Metadata-only admission for native machine backings. Imports start no process and read no file.
+'use strict';
+
+exports.refuseRequiredMachineTransport = function refuseRequiredMachineTransport(source, transport) {
+  const path = source.VOLTER_WORLD_INSTANCE;
+  if (!path) {
+    if (source.VOLTER_WORLD) throw new Error('World machine execution has no retained credential declaration');
+    return; // No registered World declaration is asserted by the standalone provider.
+  }
+  const instance = JSON.parse(require('node:fs').readFileSync(path, 'utf8'));
+  if (!instance || typeof instance !== 'object' || Array.isArray(instance)
+    || !instance.env || instance.env.VOLTER_WORLD_INSTANCE !== path || instance.env.VOLTER_WORLD !== source.VOLTER_WORLD
+    || !Object.hasOwn(instance, 'requiredCredentials')) throw new Error('World machine boot lacks its own retained credential declaration');
+  const record = instance.requiredCredentials;
+  if (!record || typeof record !== 'object' || Array.isArray(record)
+    || Object.keys(record).some(key => !['version', 'owners', 'valuesSha256'].includes(key))
+    || !Object.hasOwn(record, 'version') || record.version !== 1 || !Object.hasOwn(record, 'owners')
+    || !record.owners || typeof record.owners !== 'object' || Array.isArray(record.owners))
+    throw new Error('World machine credential declaration has an unsupported version or shape');
+  if (Object.keys(record.owners).length) {
+    const error = new Error(`${transport} does not carry required credential bindings`);
+    error.code = 'WORLD_MACHINE_CAPABILITY_GAP';
+    throw error;
+  }
+  if (Object.hasOwn(record, 'valuesSha256')) {
+    const empty = require('node:crypto').createHash('sha256').update('[]').digest('hex');
+    if (record.valuesSha256 !== empty) throw new Error('World machine empty credential declaration changed');
+  }
+};

package/dist/required-credential-transport.d.cts

@@ -0,0 +1,3 @@
+/** Refuse a registered World's required declarations before a backing with no credential transport acts.
+ * Reads only the actual instance named by the provider's own environment; standalone providers assert no World proof. */
+export declare function refuseRequiredMachineTransport(source: Readonly<Record<string, string | undefined>>, transport: string): void;

package/dist/src/blob-store.d.ts

@@ -19,7 +19,22 @@ export interface BlobStore {
      *  whole. Optional: `readBlobRange` falls back to `get` (a whole read) for a backend without it —
      *  the hosted World's R2 store today. */
     getRange?(key: string, start: number, endInclusive: number): Promise<Uint8Array | null>;
+    /** A body's chunks written to `key` as they arrive and hashed as they are written, kept (atomically, as `put`)
+     *  only when `accept` holds for their size and SHA-256; otherwise nothing is kept. True when kept. So an upload
+     *  of a large object (a model's weights) never holds more than a chunk. Optional: `writeBlobStream` collects
+     *  the chunks and `put`s them for a backend without it. */
+    putStream?(key: string, chunks: AsyncIterable<Uint8Array>, accept: (written: BlobWritten) => boolean): Promise<boolean>;
 }
+/** What a streamed write wrote: its byte length and its SHA-256 (hex). */
+export type BlobWritten = {
+    size: number;
+    sha256: string;
+};
+/** A body's chunks to `key` through the active store, kept when `accept` holds for what was written (the store's
+ *  own streamed write where it has one, else the chunks collected and `put`). True when kept. */
+export declare function writeBlobStream(key: string, chunks: AsyncIterable<Uint8Array>, accept: (written: BlobWritten) => boolean): Promise<boolean>;
+/** A web stream's chunks, read by its reader (a browser's ReadableStream need not be async-iterable). */
+export declare function streamChunks(body: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array>;
 /** A range of the blob at `key` through the active store: native when the store has it, else sliced. */
 export declare function readBlobRange(key: string, start: number, endInclusive: number): Promise<Uint8Array | null>;
 /** Today's layout, verbatim: keys are filesystem paths. */
@@ -30,6 +45,7 @@ export declare class FsBlobStore implements BlobStore {
     });
     get(key: string): Promise<Uint8Array | null>;
     put(key: string, bytes: Uint8Array): Promise<void>;
+    putStream(key: string, chunks: AsyncIterable<Uint8Array>, accept: (written: BlobWritten) => boolean): Promise<boolean>;
     exists(key: string): Promise<boolean>;
     remove(key: string): Promise<void>;
     list(prefix: string): Promise<string[]>;

package/dist/src/blob-store.js

@@ -19,11 +19,50 @@
 // local worlds change NOTHING — scrub, backup, and inspection all still see the same tree.
 // A remote adapter maps the path to an object key (namespace prefix + path).
 import { createHash, randomUUID } from 'node:crypto';
-import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { volterHome } from "./volter-home.js";
 import { sharedBlobIndex } from "./shared-blob-index.js";
 import { refuseReadOnlyWrite, writesRefused } from "./request-scope.js";
+/** A body's chunks to `key` through the active store, kept when `accept` holds for what was written (the store's
+ *  own streamed write where it has one, else the chunks collected and `put`). True when kept. */
+export async function writeBlobStream(key, chunks, accept) {
+    const store = getActiveBlobStore();
+    if (store.putStream)
+        return store.putStream(key, chunks, accept);
+    const parts = [];
+    let size = 0;
+    for await (const chunk of chunks) {
+        parts.push(chunk);
+        size += chunk.byteLength;
+    }
+    const bytes = new Uint8Array(size);
+    let at = 0;
+    for (const part of parts) {
+        bytes.set(part, at);
+        at += part.byteLength;
+    }
+    if (!accept({ size, sha256: blobDigest(bytes) }))
+        return false;
+    await store.put(key, bytes);
+    return true;
+}
+/** A web stream's chunks, read by its reader (a browser's ReadableStream need not be async-iterable). */
+export async function* streamChunks(body) {
+    const reader = body.getReader();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            if (value)
+                yield value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
 /** A range of the blob at `key` through the active store: native when the store has it, else sliced. */
 export async function readBlobRange(key, start, endInclusive) {
     // one clamping for every backend: a negative or non-finite start reads from 0, a range that ends
@@ -72,6 +111,40 @@ export class FsBlobStore {
             rmSync(tmp, { force: true });
         }
     }
+    async putStream(key, chunks, accept) {
+        mkdirSync(dirname(key), { recursive: true });
+        const tmp = `${key}.tmp.${randomUUID()}`;
+        const hash = createHash('sha256');
+        let size = 0;
+        try {
+            const fd = openSync(tmp, 'wx');
+            try {
+                for await (const chunk of chunks) {
+                    hash.update(chunk);
+                    size += chunk.byteLength;
+                    for (let at = 0; at < chunk.byteLength;)
+                        at += writeSync(fd, chunk, at, chunk.byteLength - at);
+                }
+            }
+            finally {
+                closeSync(fd);
+            }
+            const sha256 = hash.digest('hex');
+            if (!accept({ size, sha256 }))
+                return false;
+            renameSync(tmp, key);
+            if (this.options.sharedIndexRoot !== false) {
+                try {
+                    sharedBlobIndex(this.options.sharedIndexRoot ?? join(volterHome(), 'blob-index-v1'), statSync(dirname(key)).dev, sha256).record(key);
+                }
+                catch { /* The index is an optimization, never a prerequisite for a blob write. */ }
+            }
+            return true;
+        }
+        finally {
+            rmSync(tmp, { force: true });
+        }
+    }
     async exists(key) {
         return existsSync(key);
     }
@@ -180,7 +253,9 @@ function readOnlyBlobs(store) {
         exists: (key) => store.exists(key),
         list: (prefix) => store.list(prefix),
         size: (key) => store.size(key),
+        ...(store.getRange ? { getRange: (key, start, endInclusive) => store.getRange(key, start, endInclusive) } : {}),
         put: async () => { refuseReadOnlyWrite('blobs'); },
+        putStream: async () => { refuseReadOnlyWrite('blobs'); return false; },
         remove: async () => { refuseReadOnlyWrite('blobs'); },
     };
 }