@volter/browser-substrate 0.1.103 → 0.1.105

package/dist/index.js

@@ -10,6 +10,7 @@ import { validateImageCacheEntries } from "./image-packs.js";
 import { PROGRAM_ARCHIVE_RECEIPT, imageProgramLayerRoot, programArchiveReceipt } from "@volter/browser-runtime/browser-image-layers.js";
 import { attachLocalPreviewSockets, injectLoopbackIntoPreviews } from "./local-preview.js";
 import { exposeBrowserCookieJar, openPersistentBrowserCookieJar } from "@volter/browser-runtime/browser-cookie-jar.js";
+import { holdOriginForProject } from "./origin-reset.js";
 import { attachTabnodeCookieJar } from "@volter/browser-node/tabnode-cookie-jar.js";
 import { browserProjectId, buildContainerFile, classifyContainerFile, clearVirtualFileSystem, containerLaneTableForRuntime, parseContainerFile, probeBrowserCapabilities, loadProgramHttpTransportPolicies, rebaseCommandPaths, resolveRelayService, stagePath, syncContainerBuild, BrowserSandboxBridge, HostFetchServiceRegistry, browserRegisteredServer, HOST_FETCH_DEFAULT_MAX_REQUEST_BYTES, } from "@volter/browser-runtime";
 import { createIsolatedBrowserNodeRuntime, createWorkerBrowserNodeRuntime, registerPackageManagerAliases, withTabnodeHttpStreaming, prepareBrowserNodeProgram, VIRTUAL_HOST_PARAMETER, warmPreparedImage, } from "@volter/browser-node";
@@ -144,16 +145,36 @@ function rejectedReady(reason) {
     ready.catch(() => undefined);
     return ready;
 }
+async function fetchImageManifest(name, url) {
+    const response = await nativeFetch(url, { cache: "no-store" });
+    const type = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() ?? "";
+    if (!response.ok || !/^(?:application|text)\/(?:[\w.+-]+\+)?json$/u.test(type)) {
+        throw new Error(`image ${name} not found at ${url} (HTTP ${response.status}, ${type || "no content type"}). Build one with browser-substrate build.`);
+    }
+    let source;
+    try {
+        source = await response.json();
+    }
+    catch (cause) {
+        throw new Error(`image ${name} at ${url} is invalid JSON`, { cause });
+    }
+    return validateImageManifest(source);
+}
 export async function openProject(nameOrOptions = {}) {
     // An open that fails after starting the engine's worker leaves nothing
     // running: what it started is disposed before the failure is reported.
     const started = [];
+    const releaseOrigin = await holdOriginForProject();
     try {
-        return await openProjectTracking(nameOrOptions, (node) => { started.push(node); });
+        const project = await openProjectTracking(nameOrOptions, (node) => { started.push(node); });
+        const dispose = project.dispose.bind(project);
+        project.dispose = async () => { await dispose(); await releaseOrigin(); };
+        return project;
     }
     catch (cause) {
-        for (const node of started)
-            await node.runtime.dispose().catch(() => undefined);
+        const cleanup = await Promise.allSettled(started.map((node) => node.runtime.dispose()));
+        if (cleanup.every((result) => result.status === "fulfilled"))
+            await releaseOrigin();
         throw cause;
     }
 }
@@ -167,10 +188,7 @@ async function openProjectTracking(nameOrOptions, track) {
         throw new Error(`Browser runtime unsupported: ${capabilities.missing.join(", ")}`);
     const name = options.name ?? "app";
     const manifestUrl = options.manifestUrl ?? imageManifestPath(name);
-    const response = await nativeFetch(manifestUrl, { cache: "no-store" });
-    if (!response.ok)
-        throw new Error(`No image named ${name}: ${manifestUrl} answered ${response.status}. Build one with browser-substrate build.`);
-    const read = validateImageManifest(await response.json());
+    const read = await fetchImageManifest(name, manifestUrl);
     // A caller's command in place of the image's own: the project, its packages
     // and its programs as the image places them, and this run in them.
     const manifest = options.command === undefined || read.setup.kind === "dockerfile" ? read : { ...read, setup: { ...read.setup, dev: options.command } };
@@ -199,8 +217,9 @@ async function openProjectTracking(nameOrOptions, track) {
     };
     // Begun before anything else: nothing waits for it, and whatever asks for
     // an entry first finds it kept, or fetches it as it would have.
-    if (manifest.caches && !isDryRun())
-        void restoreImageCaches(manifest.caches.url, browserProjectId(manifest.project ?? `substrate-${options.name ?? "app"}`), nativeFetch).catch((cause) => console.warn(`[caches] ${cause instanceof Error ? cause.message : String(cause)}`));
+    const restoringCaches = manifest.caches && !isDryRun()
+        ? restoreImageCaches(manifest.caches.url, browserProjectId(manifest.project ?? `substrate-${options.name ?? "app"}`), nativeFetch).catch((cause) => console.warn(`[caches] ${cause instanceof Error ? cause.message : String(cause)}`))
+        : Promise.resolve();
     const output = options.onOutput ?? (() => undefined);
     // A step that held the page a while says so when the next begins: a boot
     // that stalls is found in its own log, not by guessing which step it was.
@@ -266,6 +285,7 @@ async function openProjectTracking(nameOrOptions, track) {
         bundler: { workerUrl: "/bundler-worker.js", rollupModuleUrl: "/rollup/rollup.browser.js", esbuildModuleUrl: "/esbuild/browser.min.js", esbuildWasmUrl: "/esbuild/esbuild.wasm" },
         // The shell's own Rolldown binding, or the project's, built for its version at image time.
         rolldownModuleUrl: manifest.rolldown?.url ?? "/rolldown/factory.mjs",
+        ...(manifest.rolldown ? { rolldownVersion: manifest.rolldown.version } : {}),
         // Node's type stripper, amaro, served from this origin: a `.ts` entry runs as Node runs one.
         typeStripperModuleUrl: "/amaro/amaro.js",
         // What the module stand-ins compute with, served from this origin: Prisma's schema parser.
@@ -307,6 +327,7 @@ async function openProjectTracking(nameOrOptions, track) {
     status(`The runtime started in ${Math.round(performance.now() - runtimeStartedAt)} ms`);
     bootStage({ id: "machine", label: "Starting the machine", state: "done", detail: isolated ? "isolated runtime" : "runtime and store" });
     const { runtime, container } = node;
+    let closeCookies;
     const preparedProject = Boolean(node.workspaceStore?.preparedImage && node.workspaceStore.preparedImage === manifest.layers?.digest);
     /** Whether this open's prepared install already placed this archive at this root (ADR-0085). */
     const preparedTree = (root, integrity) => preparedProject
@@ -326,27 +347,16 @@ async function openProjectTracking(nameOrOptions, track) {
     }
     // Once the app has answered its first page, what a first boot read is the
     // image's startup set: the host keeps it for the next first boot. A repeat
-    // boot holds every range earlier boots read, so it records nothing. The set
-    // is kept in the order the boot first held each range, sampled as it runs,
-    // so the next first boot fetches the World's ranges before the app's.
+    // boot holds every range earlier boots read, so it records nothing. Every
+    // reader stamps a range's first read, so one read of the set at the end
+    // gives the order the boot first needed each range.
     let startupRecorded = false;
-    const startupOrder = new Set();
-    const sampleStartup = async () => { for (const range of await imageStartup.imageStartupSet())
-        startupOrder.add(range); };
-    const startupSampler = startupUrl && imageStartup.imageStartupSet
-        ? setInterval(() => { if (!preparedProject || startupRecorded)
-            clearInterval(startupSampler);
-        else
-            void sampleStartup(); }, 250)
-        : undefined;
     const recordStartup = () => {
-        if (startupSampler !== undefined)
-            clearInterval(startupSampler);
         if (!startupUrl || !preparedProject || !imageStartup.imageStartupSet || startupRecorded)
             return;
         startupRecorded = true;
-        void sampleStartup().then(() => startupOrder.size === 0 ? undefined
-            : nativeFetch(startupUrl, { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ version: 1, ranges: [...startupOrder] }) }))
+        void imageStartup.imageStartupSet().then((ranges) => ranges.length === 0 ? undefined
+            : nativeFetch(startupUrl, { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ version: 1, ranges }) }))
             .catch((cause) => console.warn(`[startup] ${cause instanceof Error ? cause.message : String(cause)}`));
     };
     // An image that links a Node install runs Node: its worker loads the
@@ -435,6 +445,7 @@ async function openProjectTracking(nameOrOptions, track) {
         // before the worker is, which binds the bridge's message handler.
         if (bridge.initServiceWorker) {
             const cookies = await openPersistentBrowserCookieJar(projectId);
+            closeCookies = () => cookies.dispose();
             attachTabnodeCookieJar(container.serverBridge, cookies);
             exposeBrowserCookieJar(window, cookies);
         }
@@ -852,6 +863,7 @@ async function openProjectTracking(nameOrOptions, track) {
      * re-applied. Then the World's own runtime brings its twins up. Answers
      * the way to run a command attached to the World.
      */
+    let stopWorld;
     const attachWorld = async (world, preparedBodies) => {
         const root = `${WORLDS_ROOT}/${world.name}`;
         const record = `${root}/.substrate-world.json`;
@@ -923,6 +935,24 @@ async function openProjectTracking(nameOrOptions, track) {
         const cli = /^node "([^"]+)"/mu.exec(stub)?.[1];
         if (!cli)
             throw new Error(`World ${world.name}: node_modules/.bin/volter-world is not a stub naming the CLI.`);
+        stopWorld = async (say) => {
+            const run = async (verb) => {
+                say(`World ${world.name}: ${verb}`);
+                const command = `node ${cli} ${verb} ${world.name} --root ${root} --json`;
+                const result = await runtime.start(command, { cwd: root, env }).result;
+                if (result.exitCode !== 0)
+                    throw new Error(`World ${world.name}: ${verb} refused shutdown (exit ${result.exitCode}). ${result.stderr.trim()}`);
+                say(`World ${world.name}: ${verb} finished`);
+                return result.stdout;
+            };
+            // Retire only consumers the CLI proves no longer live; down retains data.
+            await run("consumers retire");
+            await run("down");
+            const stopped = JSON.parse(await run("status"));
+            if (stopped.running !== false || !Array.isArray(stopped.livePids) || stopped.livePids.length) {
+                throw new Error(`World ${world.name}: shutdown was not verified. Saved state has not been cleared.`);
+            }
+        };
         // The World's data is its account: an instance here boots over it, never from nothing.
         const up = `node ${cli} up ${root}/${world.config} --name ${world.name} ${world.environmentOutputFlag ?? "--env-file"} ${root}/world.env --root ${root} --keep-state`;
         status(`$ ${up}`);
@@ -1397,9 +1427,6 @@ async function openProjectTracking(nameOrOptions, track) {
                 await worldAttachment.catch(() => undefined);
             await Promise.allSettled(preparation);
             setupFailure = error;
-            // A boot whose app never answered read no startup set.
-            if (startupSampler !== undefined)
-                clearInterval(startupSampler);
             // The page's log says why, in full, the moment setup stops.
             output({ stream: "stderr", text: `\nsetup stopped: ${describeFailure(error)}\n\n` });
         }
@@ -1516,7 +1543,7 @@ async function openProjectTracking(nameOrOptions, track) {
             try {
                 // A source edit may move preparation to the host. Keep that fact even
                 // if a later edit returns to a browser-buildable image.
-                const latest = validateImageManifest(await (await fetch(imageManifestPath(name), { cache: "no-store" })).json());
+                const latest = await fetchImageManifest(name, manifestUrl);
                 recordPreparation(execution, latest.preparation);
                 // A lockfile edit is another plan; the setup that runs again reads the current one.
                 if (latest.dependencies)
@@ -1854,6 +1881,24 @@ async function openProjectTracking(nameOrOptions, track) {
                 close: async () => { unlisten?.(); unlisten = undefined; await handle.close(); },
             };
         },
+        async shutdown(say = () => undefined) {
+            // Startup must settle before issuing lifecycle commands against its World.
+            await project.ready.catch(() => undefined);
+            await restoringCaches;
+            setupAbort.abort(new Error("The project is shutting down."));
+            await feed?.close();
+            await feed?.idle;
+            say("Stopping the application");
+            await stack?.stop();
+            process?.kill();
+            await process?.result.catch(() => undefined);
+            if (stopWorld) {
+                say("Stopping the World");
+                await stopWorld(say);
+            }
+            say("Closing runtime and storage workers");
+            await project.dispose();
+        },
         dispose() {
             if (disposePromise)
                 return disposePromise;
@@ -1869,8 +1914,6 @@ async function openProjectTracking(nameOrOptions, track) {
                     }
                 };
                 setupAbort.abort(new Error("The project was closed."));
-                if (startupSampler !== undefined)
-                    clearInterval(startupSampler);
                 await release(() => feed?.close());
                 await release(async () => { await feed?.idle; });
                 await release(async () => { await stack?.stop(); });
@@ -1883,6 +1926,7 @@ async function openProjectTracking(nameOrOptions, track) {
                 await release(() => { stopUnavailableChromium?.(); });
                 await release(() => bridge?.dispose());
                 await release(() => runtime.dispose());
+                await release(async () => { await closeCookies?.(); });
                 if (failures.length === 1)
                     throw failures[0];
                 if (failures.length > 1)