@wenathlan/saddle 2.0.154 → 2.0.155

package/Dockerfile

@@ -1,17 +1,26 @@
 # syntax=docker/dockerfile:1
 # saddle v2.0.0 grand merge — THE ONE CONTAINER FILE.
 #
+# build context: this file COPYs from two trees (saddle/ and the
+# engine-ownership sibling vault/), so every build runs from the
+# repository root with an explicit -f: docker build -f saddle/Dockerfile .
+# (add --target saddle-runtime for the node service or --target
+# qemu-runtime for the guest runner). building from inside saddle/
+# breaks the vault COPY - the sibling rides the context beside this
+# directory, never inside it.
+#
 # this Dockerfile carries BOTH container surfaces of the merged repository:
 #   1. the saddle virtual-hardware engine image (the five stages below:
 #      builder, python-bridge, qemu, qemu-runtime, runtime) — the default
 #      build target, published as ghcr.io/wenathlan/saddle:vhe-<version>
-#      across three profiles and four architectures;
+#      across three profiles and eleven architectures;
 #   2. the saddle node-engine image (the saddle-build and saddle-runtime
 #      stages at the end of this file, folded from the former
 #      dockerfile.saddle) — an explicit build target
 #      (`docker build --target saddle-runtime .`), the node 26 storage and
 #      compute service published as ghcr.io/wenathlan/saddle:<version>
-#      across the four-arch family standard (amd64, arm64, ppc64le, s390x
+#      across the eleven-arch family standard (amd64, amd64/v2, arm64,
+#      arm/v7, arm/v6, ppc64le, s390x, riscv64, 386, mips64le, loong64
 #      — the trixie slim base line; the stage also builds the web SPA so
 #      the image serves the self-hosted console via `node /app/webserver.ts`).
 #
@@ -53,17 +62,22 @@
 #                  build target (docker build / the engine docker run
 #                  recipe below).
 #
-# platforms: linux/amd64, linux/arm64, linux/ppc64le and linux/s390x
-# through buildx --platform (the four-arch registry surface); every
+# platforms: linux/amd64, linux/amd64/v2, linux/arm64, linux/arm/v7,
+# linux/arm/v6, linux/ppc64le, linux/s390x, linux/riscv64, linux/386,
+# linux/mips64le and linux/loong64 through buildx --platform (the
+# eleven-arch registry surface — the complete linux platform list
+# docker/buildx carries, the owner's law: eleven OS architectures for
+# every container of every application); every
 # stage compiles for the portable baseline of its target architecture
-# by default (x86-64 / armv8-a / power8 / z196, resolved from
-# TARGETARCH) so the layers stay valid on every host and every
-# gha-cached runner cpu; pass --build-arg VHE_MARCH=native for
+# by default (x86-64 / i686 / armv8-a / armv7-a / armv6 / power8 / z196 /
+# rv64gc / mips64r2 / loongarch64, resolved from
+# TARGETARCH and TARGETVARIANT) so the layers stay valid on every host
+# and every gha-cached runner cpu; pass --build-arg VHE_MARCH=native for
 # host-tuned local builds, or an explicit -march value when
 # cross-building for a known deployment target.
 #
 # profiles: the three profiles (max, balanced, lite) are all built for
-# all four architectures; each profile carries a distinct virtual CPU
+# all eleven architectures; each profile carries a distinct virtual CPU
 # identity (model name, vcpus, threads, ram) baked into /etc/virtual.
 #
 # the one container file (the gateway 1.1.5 standard): the compose stack
@@ -94,7 +108,7 @@
 #     -v vmdata:/data/vmdata -v webdata:/data/web \
 #     -v ./vm.config.json:/engine/vm.config.json:ro \
 #     -e PORT=8080 -e NODE_ENV=production -p 31280:8080 \
-#     ghcr.io/wenathlan/saddle:vhe-2.1.6
+#     ghcr.io/wenathlan/saddle:vhe-2.0.154
 #
 #   vheqemu (the guest runner; build it first with
 #   docker build --target qemu-runtime -t saddle/qemu:11.1.0 . because the
@@ -128,7 +142,7 @@
 #     -e VHE_GPU_PROFILE=b200 -e VHE_GPUS=8 -e VHE_MIG=1 \
 #     -e VHE_SMI_DRIVER=575.57.08 -e VHE_SMI_CUDA=12.9 \
 #     -e VHE_SMI_INTERVAL=30 -e VHE_SKIP_XVFB=1 -e VHE_SKIP_VALIDATE=1 \
-#     ghcr.io/wenathlan/saddle:vhe-2.1.6 /bin/bash -c '
+#     ghcr.io/wenathlan/saddle:vhe-2.0.154 /bin/bash -c '
 #       while true; do
 #         /usr/local/bin/nvidia-smi "$VHE_GPU_PROFILE" "$VHE_GPUS" || true
 #         sleep "$VHE_SMI_INTERVAL"
@@ -145,7 +159,7 @@
 #     -v qemudata:/data/qemudata \
 #     -v ./qemubridge.py:/engine/qemubridge.py:ro \
 #     -e QMP_SOCKET=/run/vhe/vm.qmp -e PYTHONUNBUFFERED=1 \
-#     ghcr.io/wenathlan/saddle:vhe-2.1.6 \
+#     ghcr.io/wenathlan/saddle:vhe-2.0.154 \
 #     python3 /engine/qemubridge.py --socket /run/vhe/vm.qmp status
 #
 #   saddle-node (the node-engine service, the former compose.yml
@@ -159,7 +173,7 @@
 #     --log-driver json-file --log-opt max-size=50m --log-opt max-file=5 \
 #     --tmpfs /tmp:size=2g,mode=1777 \
 #     -e SADDLE_MEMORY_ENGINE=ram -e SBOT_PLATFORM= -e SBOT_CDN_URL= \
-#     ghcr.io/wenathlan/saddle:2.1.6 \
+#     ghcr.io/wenathlan/saddle:2.0.154 \
 #     node dist/cli.js plan
 #
 #   observability (the former prometheus scraper of the full profile)
@@ -175,7 +189,7 @@
 # ever binds a hardcoded address.
 
 # Base image contract (the gateway family policy): tags only, never a
-# @sha256: digest. A single digest cannot serve the four-architecture
+# @sha256: digest. A single digest cannot serve the eleven-architecture
 # matrix this image ships (the registry resolves the tag per platform),
 # and a digest written here would be a hardcoded hash - the checksums
 # that exist are generated by the GitHub runners and published as
@@ -204,12 +218,15 @@ ARG QEMU_VERSION="11.1.0"
 FROM ${UBUNTU} AS builder
 ARG TARGETPLATFORM
 ARG TARGETARCH
+ARG TARGETVARIANT
 ARG BUILDARCH
 ARG LLVM_VERSION
 ARG NODE_VERSION
 ARG MESA_VERSION
-# empty = portable baseline resolved from TARGETARCH at the compile step
-# (x86-64 / armv8-a); "native" is the opt-in for host-tuned local builds.
+# empty = portable baseline resolved from TARGETARCH (and TARGETVARIANT
+# for the 32-bit arm legs) at the compile step (x86-64 / i686 / armv8-a /
+# armv7-a / armv6 / power8 / z196 / rv64gc / mips64r2 / loongarch64);
+# "native" is the opt-in for host-tuned local builds.
 ARG VHE_MARCH=""
 # NOTE: the VHE_PROFILE_* build-args are deliberately NOT declared in the
 # builder stage. The builder compiles mesa/node/native shims which are
@@ -287,15 +304,18 @@ RUN set -eux; \
 # it off, the build is rust-free.
 
 # node 26.7.0 (current line, v8 14.6, temporal api, NODE_MODULE_VERSION 147).
-# amd64 and arm64 install the pinned nodesource deb; ppc64le (any arch the
-# nodesource apt repo does not carry) falls back to the official nodejs.org
-# binary tarball, extracted straight into /usr so bin/node, include/node and
+# amd64 (with its amd64/v2 variant) and arm64 install the pinned nodesource
+# deb; every architecture the nodesource apt repo does not carry (ppc64le,
+# s390x, riscv64, loong64, mips64le, arm and 386 - the eleven-arch law's
+# non-nodesource legs) falls back to the official nodejs.org binary tarball
+# (mapped to the nodejs.org arch spellings: x64, armv7l, mips64el, x86),
+# extracted straight into /usr so bin/node, include/node and
 # lib/node_modules land exactly where the nodesource package (and the runtime
 # stage COPY --from=builder directives) expect them. the node headers
 # (/usr/include/node) are required by the ADDON build mode of gpumonitor.cpp.
 RUN set -eux; \
     nodesrc_ok="1"; \
-    case "${TARGETARCH}" in ppc64le|s390x|riscv64|loongarch64) nodesrc_ok="0" ;; esac; \
+    case "${TARGETARCH}" in ppc64le|s390x|riscv64|loong64|loongarch64|mips64le|arm|386) nodesrc_ok="0" ;; esac; \
     if [ "$nodesrc_ok" = "1" ]; then \
         # the version-line setup script (setup_26.x) is the nodesource
         # distribution contract: no hardcoded digest in this file. The
@@ -312,7 +332,14 @@ RUN set -eux; \
             "nodejs=${NODE_VERSION}-1nodesource1" \
             || apt-get install -y --no-install-recommends nodejs; \
     else \
-        tarball="node-v${NODE_VERSION}-linux-${TARGETARCH}.tar.xz"; \
+        case "${TARGETARCH}" in \
+            amd64) nodearch="x64" ;; \
+            386|i386) nodearch="x86" ;; \
+            arm) nodearch="armv7l" ;; \
+            mips64le) nodearch="mips64el" ;; \
+            *) nodearch="${TARGETARCH}" ;; \
+        esac; \
+        tarball="node-v${NODE_VERSION}-linux-${nodearch}.tar.xz"; \
         curl -fsSL --retry 5 --retry-all-errors -o "/tmp/${tarball}" \
             "https://nodejs.org/dist/v${NODE_VERSION}/${tarball}"; \
         tar -xJf "/tmp/${tarball}" -C /usr --strip-components=1; \
@@ -461,12 +488,20 @@ RUN set -eux; \
     # portable baseline per architecture, with the ARCH FLAG the compiler
     # family actually accepts: x86 and arm speak -march; the ppc64le gcc
     # port rejects '-march=power8' ('did you mean -mcpu=power8?') so that
-    # architecture selects the -mcpu spelling; s390x accepts -march=z196.
+    # architecture selects the -mcpu spelling; s390x accepts -march=z196;
+    # the eleven-arch law's remaining legs resolve their own baselines
+    # (armv7-a / armv6 by TARGETVARIANT, rv64gc, loongarch64, mips64r2,
+    # i686 for the 386 leg).
     archflag="-march"; \
     case "${TARGETARCH}" in \
         arm64|aarch64) march="armv8-a" ;; \
+        arm) if [ "${TARGETVARIANT}" = "v7" ]; then march="armv7-a"; else march="armv6"; fi ;; \
         ppc64le) march="power8"; archflag="-mcpu" ;; \
         s390x) march="z196" ;; \
+        riscv64) march="rv64gc" ;; \
+        loong64|loongarch64) march="loongarch64" ;; \
+        mips64le) march="mips64r2" ;; \
+        386|i386) march="i686" ;; \
         *) march="x86-64" ;; \
     esac; \
     if [ -n "${VHE_MARCH}" ]; then march="${VHE_MARCH}"; archflag="-march"; fi; \
@@ -655,10 +690,10 @@ ENTRYPOINT ["/usr/bin/tini", "--", "qemu-system-x86_64"]
 # ships native bindings for the builder platforms - the per-arch legs never
 # run it under QEMU. The base rides the family tag contract (tags only,
 # never a @sha256: digest - a single digest cannot serve the
-# four-architecture matrix the registry resolves per platform).
-FROM --platform=$BUILDPLATFORM node:26.8.1-slim AS saddle-build
+# eleven-architecture matrix the registry resolves per platform).
+FROM --platform=$BUILDPLATFORM node:26.13.0-slim AS saddle-build
 
-ARG SADDLE_VERSION
+ARG SADDLE_VERSION=2.0.154
 WORKDIR /app
 
 ENV NPM_CONFIG_LEGACY_PEER_DEPS=true
@@ -671,9 +706,7 @@ COPY saddle/ .
 # so the vault sources ride the context beside the saddle and land at
 # /vault where the import resolves (the family context fix).
 COPY vault/ /vault
-RUN npm run build:engine \
-    && node --check dist/cli.js \
-    && npm run web:build:pages \
+RUN npm run web:build:pages \
     # the theme build emits the hashed SPA bundles straight at the app
     # root (the family static-first vite contract): stage them into a
     # clean folder so the runtime stages copy exactly the console
@@ -914,9 +947,15 @@ COPY --from=python-bridge /bridge/qemubridge.py /engine/qemubridge.py
 # the engine sources and the specification files consumed at runtime
 # (docker.config "final" stage copies the whole tree; the flat layout
 # keeps that a single COPY layer).
-COPY saddle/*.ts saddle/package.json saddle/tsconfig.json saddle/biome.jsonc saddle/jsdom.d.ts /engine/
+COPY saddle/*.ts saddle/package.json saddle/tsconfig.json saddle/biome.jsonc /engine/
 COPY saddle/processors.json saddle/gpus.json saddle/cores.json saddle/boards.json saddle/vm.config.json saddle/virtualhardware.json /engine/
 COPY saddle/qemu.config saddle/mttg.config saddle/passage.config saddle/docker.config saddle/mime.types /engine/
+# the engine-ownership sibling: db.ts pulls labels.ts whose
+# ../vault/labelstore.ts import resolves at /vault - the vault source
+# rides the context beside the saddle and lands at /vault where the
+# import resolves (the same family context fix as the saddle-build
+# stage), so the engine webserver below finds the label store.
+COPY vault/labelstore.ts /vault/labelstore.ts
 
 # the web node ships inside the main container: the mesh edition (auth,
 # sqlite database, dashboard and the browser sandbox pages) runs from the
@@ -940,8 +979,13 @@ RUN set -eux; \
     mkdir -p /etc/OpenCL/vendors; \
     case "${TARGETARCH}" in \
         arm64|aarch64) ln -sf lvp_icd.aarch64.json /usr/share/vulkan/icd.d/lvp_icd.json ;; \
+        arm) ln -sf lvp_icd.arm.json /usr/share/vulkan/icd.d/lvp_icd.json ;; \
         ppc64le) ln -sf lvp_icd.ppc64le.json /usr/share/vulkan/icd.d/lvp_icd.json ;; \
         s390x) ln -sf lvp_icd.s390x.json /usr/share/vulkan/icd.d/lvp_icd.json ;; \
+        riscv64) ln -sf lvp_icd.riscv64.json /usr/share/vulkan/icd.d/lvp_icd.json ;; \
+        loong64|loongarch64) ln -sf lvp_icd.loongarch64.json /usr/share/vulkan/icd.d/lvp_icd.json ;; \
+        mips64le) ln -sf lvp_icd.mips64.json /usr/share/vulkan/icd.d/lvp_icd.json ;; \
+        386|i386) ln -sf lvp_icd.x86.json /usr/share/vulkan/icd.d/lvp_icd.json ;; \
         *) ln -sf lvp_icd.x86_64.json /usr/share/vulkan/icd.d/lvp_icd.json ;; \
     esac; \
     ldconfig; \
@@ -1295,7 +1339,7 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --start-interval=5s
 # OCI labels for registry introspection.
 LABEL org.opencontainers.image.title="saddle virtual-hardware engine (the grand merge)" \
       org.opencontainers.image.description="100% software virtual hardware: per-profile CPU/memory spoofing via LD_PRELOAD (max/balanced/lite), mesa 26.2.1 llvmpipe/lavapipe/rusticl, QEMU 11.1.0 TCG/MTTCG, virtual nvidia-smi adapter + NVML/CUDA shims, node 26.7.0, python bridge" \
-      org.opencontainers.image.version="2.1.6" \
+      org.opencontainers.image.version="2.0.154" \
       org.opencontainers.image.licenses="MIT" \
       org.opencontainers.image.source="https://github.com/wenathlan/saddle" \
       org.opencontainers.image.documentation="https://github.com/wenathlan/saddle/blob/main/README.md" \
@@ -1326,6 +1370,14 @@ VOLUME /data /cache/mesa_shader_cache
 # pid 1.
 ENTRYPOINT ["/entrypoint.sh"]
 
+# the engine service command: without a CMD the entrypoint exec "$@"
+# fell back to /bin/bash and the engine recipe (host 31280 -> container
+# 8080) bound nothing. the webserver is the console server the COPY
+# above landed at /engine: the default command starts it, and the
+# entrypoint exports PORT (8080 unless -e PORT overrides) before the
+# exec, so the service answers on 8080 out of the box.
+CMD ["node", "/engine/webserver.ts"]
+
 # ══════════════════════════════════════════════════════════════════════
 # saddle node-engine stages — the storage/compute node service of the
 # grand merge (folded verbatim from the former dockerfile.saddle: the
@@ -1334,9 +1386,9 @@ ENTRYPOINT ["/entrypoint.sh"]
 #   docker build --target saddle-runtime -t saddle:<version> .
 # ══════════════════════════════════════════════════════════════════════
 
-FROM node:26.8.1-slim AS saddle-runtime
+FROM node:26.13.0-slim AS saddle-runtime
 
-ARG SADDLE_VERSION
+ARG SADDLE_VERSION=2.0.154
 LABEL org.opencontainers.image.title="Saddle" \
       org.opencontainers.image.description="Storage-backed browser and compute engine (the grand-merge node service)" \
       org.opencontainers.image.source="https://github.com/wenathlan/saddle" \
@@ -1386,20 +1438,39 @@ RUN apt-get update \
     # degrades to a no-op at runtime - the sources are dead weight.
     && rm -rf node_modules/cpu-features/deps \
     && find node_modules -type f -name Dockerfile -delete
-COPY --from=saddle-build /app/dist ./dist
 # the web service surface (self-hosted console): the staged spa plus the
-# pure-node server stack (webserver.ts, db.ts, labels.ts, auth.ts,
-# mesh.ts, sandbox.ts, sandboxprofile.ts, sandboxenvprofile.ts,
-# sandboxquota.ts, mime.types, init.sql, schema.prisma) - zero npm
-# dependencies, the node 26 runtime carries everything (node:sqlite,
-# node:crypto, native type stripping for the .ts sources).
+# pure-node server stack - zero npm dependencies, the node 26 runtime
+# carries everything (node:sqlite, node:crypto, native type stripping
+# for the .ts sources). the console set closes the whole import graph:
+# webserver.ts pulls modalityregistry.ts, edgeplane.ts and
+# workloadlaw.ts; edgeplane.ts pulls foundation.ts and the edgelandes
+# family (edgelandes.ts, edgelandeshost.ts, edgelandesinproc.ts,
+# edgelandesvirtual.ts, edgelandesninety.ts); db.ts pulls labels.ts
+# whose ../vault/labelstore.ts import resolves at /vault (the family
+# context fix - the vault source lands beside /app the same way the
+# saddle-build stage lands it). with the graph closed, node
+# webserver.ts starts clean; before the fix the container crashed at
+# boot with module-not-found.
 # run the console with: docker run saddle:<version> node webserver.ts
-COPY --from=saddle-build /app/webserver.ts /app/db.ts /app/labels.ts /app/auth.ts /app/mesh.ts /app/sandbox.ts /app/sandboxprofile.ts /app/sandboxenvprofile.ts /app/sandboxquota.ts /app/mime.types /app/init.sql /app/schema.prisma ./
+COPY --from=saddle-build /app/webserver.ts /app/db.ts /app/labels.ts /app/auth.ts /app/mesh.ts /app/sandbox.ts /app/sandboxprofile.ts /app/sandboxenvprofile.ts /app/sandboxquota.ts /app/modalityregistry.ts /app/edgeplane.ts /app/workloadlaw.ts /app/foundation.ts /app/edgelandes.ts /app/edgelandeshost.ts /app/edgelandesinproc.ts /app/edgelandesvirtual.ts /app/edgelandesninety.ts /app/mime.types /app/init.sql /app/schema.prisma ./
+# the label store of the console stack: labels.ts (pulled by db.ts)
+# resolves ../vault/labelstore.ts at /vault - the same family context
+# fix the saddle-build stage applies.
+COPY --from=saddle-build /vault/labelstore.ts /vault/labelstore.ts
 COPY --from=saddle-build /out/spa ./
 
 USER node
 
-HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 CMD ["node", "dist/cli.js", "help"]
+# the console service doors: the webserver answers the engine api and the
+# staged spa on the saddle port (the source-is-library law runs the .ts
+# graph natively - node 26 strips the types, zero npm dependencies).
+ENV SADDLE_PORT=8080 \
+    SADDLE_HOST=0.0.0.0
+
+EXPOSE 8080
+
+# the health probe rides the public /health route the webserver answers
+# (node fetch, zero wget dependency on the slim debian base).
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 CMD ["node", "-e", "fetch('http://127.0.0.1:8080/health').then((r)=>{if(!r.ok)process.exit(1)}).catch(()=>process.exit(1))"]
 
-ENTRYPOINT ["node", "dist/cli.js"]
-CMD ["help"]
+ENTRYPOINT ["node", "webserver.ts"]

package/README.md

@@ -3,8 +3,8 @@
 </p>
 
 <p align="center">
-  <strong>Storage-backed jobs, scraping contracts and portable runners for Node.js.</strong><br/>
-  <strong>Binary computing engine, agent browser, scraper and packager.</strong><br/>
+  <strong>Storage-backed jobs, ninety sandbox modalities and portable runners for Node.js.</strong><br/>
+  <strong>Binary computing engine, agent browser, sandbox plane and packager.</strong><br/>
   <a href="https://github.com/wenathlan/saddle/actions/workflows/ci.yml"><img src="https://github.com/wenathlan/saddle/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
   <a href="https://github.com/wenathlan/saddle/releases/tag/v2.0.0"><img src="https://img.shields.io/badge/release-v2.0.0-d35d3d" alt="Release 2.0.0" /></a>
   <a href="https://github.com/wenathlan/saddle/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-GPL--3.0--only-202a2f" alt="GPL 3.0 only license" /></a>
@@ -31,12 +31,12 @@ domain modules land beside the saddle domains:
 | `media.ts`, `render.ts`, `quantum.ts`, `tiers.ts` | media pipeline, GPU registry, quantum simulation, tier policy |
 | `security.ts`, `alternatives.ts` | hardening gates and the alternative-stack catalog |
 | `index.html`, `App.tsx`, `Sol/` | the single SPA shell and the Sol theme (one tsx app with one stylesheet per theme) |
-| `server.ts`, `sandbox.ts` | the zero-dependency self-hosted API of the 2.0.154 grand-merge envelope (`node server.ts`; the api answers its version at `/api/v1/health`) and the browser-pure engine port |
+| `server.ts`, `sandbox.ts` | the zero-dependency self-hosted API of the 2.0.155 grand-merge envelope (`node server.ts`; the api answers its version at `/api/v1/health`) and the browser-pure engine port |
 | `vercel.json`, `netlify.toml` | the platform deploy adapters beside the surface they publish (the caddy ghost stays out of the tree) |
 | `specs/*` package exports | processors, gpus, cores, boards and the qemu/mttg/passage/docker envelopes |
 
 The full pre-merge documentation of the engine lives in
-[docs/e2ugh.engine.md](docs/e2ugh.engine.md) and its release history in
+[docs/e2ughengine.md](docs/e2ughengine.md) and its release history in
 [CHANGELOG.md (the e2ugh lineage sections)](CHANGELOG.md (the e2ugh lineage sections)).
 
 ## Start here
@@ -48,18 +48,18 @@ npm install @wenathlan/saddle
 ```
 
 ```js
-import { scrapeurl, formatforagent } from "@wenathlan/saddle";
+import { createVirtualEngine, planreport, resolvejoin } from "@wenathlan/saddle";
 
-const result = await scrapeurl("https://example.com", { format: "markdown" });
-const context = formatforagent(result, { maxchunksize: 2000, keypoints: 4 });
+const engine = createVirtualEngine({ model: "saddle-90", vcpus: 4, ramgb: 8 });
+const report = planreport(); // { plancount: 90, live: 81, host: 9, planned: 0, plananswered: true }
+const modalities = resolvejoin({ base: "balanced", gpu: false, network: false });
 
-console.log(context.summary);
+console.log(engine.id, report.plananswered, modalities[0].id);
 ```
 
-The deterministic examples and tests do not require network access or real credentials:
+The deterministic engine tests do not require network access or real credentials:
 
 ```bash
-node --import tsx docs/example-publicapi.ts
 npm test
 ```
 
@@ -90,9 +90,8 @@ The historical design treats the repository and its runner as a **virtual proces
 
 | Mode | Boundary | Typical use |
 | --- | --- | --- |
-| Fetch | no browser | Static HTML, APIs and deterministic extraction. |
+| Library | in-process function call | The npm package consumed directly by another program. |
 | Browser | caller-owned transport | Interactive pages, snapshots, tabs and actions. |
-| Auto | adaptive selection | Fetch first, then browser when the caller permits it. |
 | Headless | no visible UI | CI runners, servers and scheduled jobs. |
 | CLI or binary | packaged entry point | Operator tools or third-party compute jobs. |
 | Computer | storage-to-compute bridge | Bounded binary and memory processing. |
@@ -110,8 +109,9 @@ The engine coordinates serializable contracts rather than hiding providers. The
 | Jobs | `engine`, `scheduler`, `inprocess` | `prepare -> process -> sync -> cleanup` |
 | Storage | local, chunked, content-addressed, S3-compatible, GitHub Contents and file-hosting adapters | durable objects, ranges, dedupe and sync |
 | Working set | memory bridge, modes, objects and transforms | storage-to-compute and compute-to-storage flows |
-| Scraping | robots, cache, extraction, semantic facts, schema and normalization | bounded text, metadata, links, controls and structured output |
-| Crawl | normalization, priority frontier, BFS crawler and persistent frontier contracts | domain-aware bounded crawling |
+| Sandbox modalities | the ninety-record modality registry with the join resolver and the honest live/host/planned census | the workload never names a modality — the platform resolves the join |
+| Edge lanes | the edgelandes lane tables (sandbox jails, language toolchains, runner seats, ram recipes, delivery protocols, storage wire speakers, virtual compositions) | ninety lanes probing the host, every run in a private temp dir under a hard deadline |
+| Script lanes | sh interpretation, the house yaml subset and detached background runs | deterministic local execution through the universal runner |
 | Browser | snapshots, tabs, frames, actions, fingerprint, session and replay contracts | caller-owned browser automation without a mandatory provider |
 | Operations | queues, idempotency, saga, retry, circuit breaker, health and heartbeat | controlled execution and recovery |
 | Protocols | JSON, NDJSON, SSE, blocks, API envelopes and MCP | transport-neutral messages |
@@ -136,9 +136,9 @@ The root entry point is transport-neutral. Node filesystem, HTTP server, persist
 
 The same contracts can be surfaced as an npm library, application archive, computer runtime, desktop installer, Android APK/AAB, iOS IPA, CLI, binary, browser package, Manifest V3 extension, web/PWA artifact, LibreOffice OXT, VSIX, webhook server, MCP transport, workflow action, container image, Maven package, NuGet package or RubyGem. These surfaces are declarative target plans and caller-owned adapters around the engine; they are not separate sources of truth.
 
-### Agent context and structured output
+### The ninety sandbox modalities
 
-The extraction path is **structured-first**: metadata and schema facts are selected before free-form text, then serialized to bounded Markdown, JSON or XML. Heading-aware chunks preserve source URL, content hash, heading path and token estimates for downstream retrieval. `generateLlmsTxt` and `generateLlmsFullTxt` expose concise agent indexes with absolute links, while `estimateTokens`, `fitsInContext` and the browser context budget prevent a caller from silently exceeding its chosen model or transport limit. No model provider is mandatory; parsing and context policies remain injectable.
+The sandbox plane answers the ninety modality plan. `modalityregistry.ts` holds one honest record per modality — isolation family, drivers, hardening gates, boot budget, gpu and network paths, and a live/host/planned state that never pretends — and `resolvejoin` reads a workload request (base profile, gpu, network, isolation depth, boot budget) and answers the modality set that satisfies it, so the person chooses none and the platform resolves the join of all. The edgelandes lane tables wire the plan: ninety lanes probing their host runtime (the sandbox jails, the language toolchains, the runner seats, the ram recipes, the delivery protocols, the virtual hardware compositions), every run in a private temp dir under a hard deadline, an absent runtime answering a coded absence that names it. `scriptlanes.ts` rides the same law for scripts — sh plans, the house yaml subset and detached background runs through the universal runner — and `workloadlaw.ts` catalogs the heavy workload lane of every family app as a demand the same join resolver answers. The self-hosted surface publishes the census at `/api/v1/modalities` and the lane table at `/api/v1/edge/lanes`.
 
 ### Third-party compute identity
 
@@ -148,23 +148,18 @@ Saddle can be connected to GitHub, GitLab, Forgejo, Gitea, Codeberg, Docker or a
 
 | Export | Purpose |
 | --- | --- |
-| `saddleurl` | choose a fetch or caller-injected browser path |
-| `scrapeurl` | fetch one URL and extract bounded content |
-| `scrapehtml` | extract from HTML without network access |
-| `extractcontent` | structured extraction |
-| `serializeresult` | serialize JSON, Markdown or XML results |
-| `formatforagent` | summary, chunks and token count |
-| `chunkMarkdown` / `formatChunksForRAG` | heading-aware bounded chunks for downstream context |
-| `generateLlmsTxt` / `generateLlmsFullTxt` | agent-readable documentation indexes |
-| `estimateTokens` / `fitsInContext` | model-neutral context and cost estimates |
-| `withRetry` | bounded retry and abort handling |
-| `createServer` | caller-owned HTTP surface |
-| `batchscrape` | bounded URL groups |
-| `crawlurl` | crawl contract with domain and budget controls |
+| `createVirtualEngine` / `VirtualEngine` / `probeengine` | virtual machine lifecycle, health probes and metrics |
+| `validateSpec` / `specschema` | engine specification validation and normalization |
+| `randomPort` / `resolveHost` / `buildEndpoint` | endpoint allocation without fixed addresses |
+| `InternalMemory` / `MetricsStore` / `enginebus` | the memory bank, the metrics store and the engine event bus |
+| `MODALITIES` / `planreport` | the ninety-record modality registry and its honest census |
+| `resolvejoin` / `getmodality` | the join resolver — the workload never names a modality |
+| `edgelanes` / `edgelandesreport` | the edge lane table and its probe report |
+| `interpretsh` / `interpretyml` / `runscriptbackground` | script lanes: sh plans, yaml plans and detached runs |
+| `engine` / `scheduler` / `inprocess` / `eventbus` | job lifecycle, runner dispatch and events |
 | `browseragent` | caller-owned navigation, click, type and screenshot actions |
 | `mcpserver` / `mcptransport` | MCP tools over JSONL or HTTP |
 | `nodeserver` | Web Request/Response handler |
-| `engine` / `scheduler` | job lifecycle and runner dispatch |
 | `release-assets` | SHA256SUMS, SBOM and provenance metadata for caller-selected artifacts |
 | `releaseevidence` / `evaluateevidence` | serializable release-evidence creation and evaluation |
 | `releasereadiness` / `evidencefromverification` | readiness assessment from caller-supplied verification evidence |
@@ -175,14 +170,14 @@ The package export map is defined by the root manifest. Runnable public examples
 
 ## Browser extension
 
-The extension is a TypeScript-first Manifest V3 reference surface in [`extension/`](extension/). Its source is compiled into a stable JavaScript unpacked artifact and contains a popup, service worker, isolated content bridge, read-only page-world `pagefacts` boundary, snapshot diffs and persisted window/tab/frame context for explicit resume.
+The extension surface migrated to the devthink app with the wave 2 regrouping: it is a TypeScript-first Manifest V3 reference surface (popup, service worker, isolated content bridge, read-only page-world `pagefacts` boundary, snapshot diffs and persisted window/tab/frame context for explicit resume) that runs in the user's browser, so it is not a VM modality of the engine — its module, tracked assets and tests now live at `devthink/browserextension.ts`, the devthink root `extension*` asset family and `devthink/tests/browserextension.test.ts` (see `docs/browser.md` for the migration map).
 
 ```bash
-# build an isolated JavaScript artifact using the version supplied by the caller or release tag
-npm run extension:build -- --output build/extension
+# build an isolated JavaScript artifact from the devthink app root using the version supplied by the caller or release tag
+cd ../devthink && node --import tsx ./browserextension.ts --output build/browserextension
 
-# load build/extension from chrome://extensions
-ls build/extension/manifest.json build/extension/worker.js build/extension/content.js build/extension/popup.html
+# load build/browserextension from chrome://extensions
+ls build/browserextension/manifest.json build/browserextension/worker.js build/browserextension/content.js build/browserextension/popup.html
 ```
 
 The base permission set is `activeTab`, `scripting` and `storage`. It does not request broad host permissions, cookies, `webRequest`, debugger access or arbitrary page code execution. Optional host escalation remains caller-owned. Releases attach `saddle.extension.<version>.zip`; cross-browser profiles remain adapter work.
@@ -193,14 +188,14 @@ The base permission set is `activeTab`, `scripting` and `storage`. It does not r
 | --- | --- |
 | Credentials | injected by the caller or repository secret; never committed or printed |
 | Network | HTTP/HTTPS targets are validated; private-target access remains caller policy |
-| Crawling | robots rules, crawl delay, limits and budgets are explicit |
+| Edge lanes | every lane runs in a private temp dir under a hard deadline; the visitor law guard holds on every run |
 | Storage | adapters are replaceable; the core does not own a provider account |
 | Runtime | Node-only filesystem, HTTP, Playwright and release metadata stay outside the transport-neutral root |
 | Extension | page-world reads are bounded, token-correlated and read-only |
 | Failure | retry, circuit breaker, idempotency and resume are configurable |
 | Releases | version comes from the `vX.Y.Z` tag and must match `package.json` |
 
-Version 2.0.0 (the grand merge) absorbs the e2ugh virtual-hardware engine into the saddle engine: fifteen engine modules land at the repository root (virtualcpu, virtualmemory, virtualgpu, virtualization, orchestrator, scheduler, compute, media, render, security, performance, alternatives, tiers, quantum and the engine index core), the e2ugh static console and self-hosted API live at web, the hardware catalogs (processors, gpus, cores, boards) and the four virtual-hardware config envelopes (qemu, mttg, passage, docker) ship as package exports under specs/*, and the legacy WebScrape toolkit generation consolidates into webscrape.ts. The engine surface stays dependency-free at the root (node built-ins only). Version 1.8.19 previously while reorganizing implementation ownership into twenty correlated domains behind a transport-neutral root router. The migration groups foundation nouns, execution state, API protocols, MCP adapters, automation contracts, package delivery and mode profiles without adding a privileged effect. Existing package subpaths remain available through their updated compiled targets. The denied-by-default execution, policy, handoff and internal-API contracts remain plans or receipts until a separately approved caller adapter is supplied. The current container targets `linux/amd64`, `linux/arm64` and `linux/ppc64le`; release evidence, readiness and verification remain serializable and caller-owned.
+Version 2.0.0 (the grand merge) absorbs the e2ugh virtual-hardware engine into the saddle engine: fifteen engine modules land at the repository root (virtualcpu, virtualmemory, virtualgpu, virtualization, orchestrator, scheduler, compute, media, render, security, performance, alternatives, tiers, quantum and the engine index core), the e2ugh static console and self-hosted API live at web, the hardware catalogs (processors, gpus, cores, boards) and the four virtual-hardware config envelopes (qemu, mttg, passage, docker) ship as package exports under specs/*. The engine surface stays dependency-free at the root (node built-ins only). Version 1.8.19 previously while reorganizing implementation ownership into twenty correlated domains behind a transport-neutral root router. The migration groups foundation nouns, execution state, API protocols, MCP adapters, automation contracts, package delivery and mode profiles without adding a privileged effect. Existing package subpaths remain available through their updated compiled targets. The denied-by-default execution, policy, handoff and internal-API contracts remain plans or receipts until a separately approved caller adapter is supplied. The current container targets the eleven-architecture family surface (`linux/amd64`, `linux/amd64/v2`, `linux/arm64`, `linux/arm/v7`, `linux/arm/v6`, `linux/ppc64le`, `linux/s390x`, `linux/riscv64`, `linux/386`, `linux/mips64le`, `linux/loong64`); release evidence, readiness and verification remain serializable and caller-owned.
 
 ## Package surfaces and release automation
 
@@ -223,7 +218,7 @@ Saddle is applying to the SignPath Foundation for open-source code signing. Unti
 
 The requested policy is: **Free code signing provided by SignPath.io, certificate by SignPath Foundation**. Committers and reviewers are maintainers with write access to the public repository. Approvers are repository owners or release approvers recorded in `governance.md`. Every signed release must be built from repository source, pass the security and packaging gates, and receive manual signing approval.
 
-The core program will not transfer information to other networked systems unless specifically requested by the user or the person installing or operating it. Browser sessions, storage adapters, runners and external services remain caller-configured and subject to their own policies. See [`privacy.policy.md`](privacy.policy.md) and [`SECURITY.md`](SECURITY.md).
+The core program will not transfer information to other networked systems unless specifically requested by the user or the person installing or operating it. Browser sessions, storage adapters, runners and external services remain caller-configured and subject to their own policies. See [`privacypolicy.md`](privacypolicy.md) and [`SECURITY.md`](SECURITY.md).
 
 ## GitHub Pages web surface
 
@@ -234,7 +229,7 @@ npm run web:check
 VITE_BASE_PATH=/saddle npm run web:build:pages
 ```
 
-Small public configuration and visual assets live under `web/public/`. The obsolete `web/public/__manus__` directory is intentionally absent; the development debug collector (the visitor-browser telemetry hook at the former `web/debugcollector.ts`) left the saddle together with the scrape lanes — the engine keeps no surface that watches the user's browser.
+Small public configuration and visual assets live under `web/public/`. The obsolete `web/public/__manus__` directory is intentionally absent; the development debug collector (the visitor-browser telemetry hook at the former `web/debugcollector.ts`) left the saddle — the engine keeps no surface that watches the user's browser.
 
 ## Development
 
@@ -267,24 +262,28 @@ Remote execution, provider credentials, browser transport, persistence, proxy se
 ## Repository map
 
 ```text
-core/          errors, events, identifiers, hashing, jobs, artifacts, sessions and providers
-memory/        working-set bridge, modes, objects and transforms
-storage/       local, chunked, remote and file-hosting adapters
-scrape/        robots, cache, extraction, schema, normalization and grouped crawl contracts
-runtime/       engine orchestration, queues, idempotency, saga, resumable and session contexts
-browser/       fingerprint, session, agent and Playwright adapter contracts
-extension/     Manifest V3 reference surface and packager
-desktop/       Tauri browser application for Windows, Linux and macOS
-android/       Capacitor Android conversion target and optimized Gradle release
-ios/           Capacitor iOS conversion target and caller-owned Xcode signing
-capacitor.config.ts shared web-to-native configuration for Android and iOS
-api/           envelopes, authentication, controls, JSON/NDJSON/SSE and webhooks
-adapters/      forge, app, socket and MCP integration adapters
-automation/    workflow, bot, permission and surface automation contracts
-release/       checksums, SBOM and provenance metadata
-packager/      distribution, delivery, binary, container and multi-target artifact plans
-modes/         target mode selection, deployment plans and surface profiles
-web/           root-based static marketing site with TypeScript React source
+index.ts       the transport-neutral root barrel re-exporting every domain
+foundation.ts  errors, events, identifiers, hashing, jobs, artifacts and sessions
+execution.ts   the engine, the scheduler, the inprocess runner and the working-set contracts
+virtual.ts     memory bridge, modes, objects, transforms and the local adapters
+isolation.ts   execution request, decision, handoff and the internal api envelopes
+modalityregistry.ts the ninety-record sandbox modality catalog, the join resolver and the census
+edgelandes*.ts the edge lane tables: host jails and toolchains, inproc recipes, virtual compositions, the ninety merge seat
+edgeplane.ts   the merged lane dispatch plane and the visitor law guard
+scriptlanes.ts sh plans, the house yaml subset and detached background runs
+workloadlaw.ts the family workload seat: every app declares the lanes its workloads ride
+sandbox*.ts    the sandbox state, the declared sandbox profile and its environment adapter
+virtualcpu.ts, virtualmemory.ts, virtualgpu.ts, virtualization.ts, orchestrator.ts,
+scheduler.ts, compute.ts, media.ts, render.ts, quantum.ts, tiers.ts, security.ts,
+performance.ts, alternatives.ts
+               the e2ugh virtual-hardware engine domains landed at the root by the grand merge
+automation.ts, browser.ts, communication.ts, distribution.ts, integration.ts,
+intelligence.ts, modes.ts
+               the saddle domain routing barrel files (bot, browser, delivery, integrations, profiles)
+server.ts, webserver.ts, api.ts, cli.ts
+               the self-hosted api surfaces, the web console and the stable cli
+Sol/           the Sol theme — the platform's web surface (one tsx app, one stylesheet per theme)
+specs          processors.json, gpus.json, cores.json, boards.json and the qemu/mttg/passage/docker/vm envelopes
 tests/         deterministic engine and extension coverage
 docs/          architecture, API, security, release and registry notes
 ```
@@ -293,7 +292,7 @@ The engine is TypeScript-first ESM with English JSDoc comments and a generated J
 
 ## Historical documentation
 
-The repository history contains 41 root README revisions and several surface-specific records. Their durable ideas are consolidated here: storage-backed execution, bounded working sets, replaceable runners, content extraction, browser actions, workflow delivery, multi-registry packaging, explicit recovery contracts and caller-owned integrations. Historical references that describe superseded identities, obsolete Node baselines, speculative provider quotas, unavailable hosted services or removed layouts remain historical evidence rather than current promises.
+The repository history contains 41 root README revisions and several surface-specific records. Their durable ideas are consolidated here: storage-backed execution, bounded working sets, replaceable runners, browser actions, workflow delivery, multi-registry packaging, explicit recovery contracts and caller-owned integrations. Historical references that describe superseded identities, obsolete Node baselines, speculative provider quotas, unavailable hosted services or removed layouts remain historical evidence rather than current promises.
 
 ## Current scope
 
@@ -309,7 +308,7 @@ Saddle is distributed under the [GNU General Public License v3.0 only](LICENSE).
 
 # Saddle Sol
 
-Saddle is the 20-modality sandbox platform of the DevThink family: one engine spanning compute, virtualization, media, mesh, automation and the other modalities, exposed as a self-hosted site. This Sol theme is the platform's web surface — a Vite + React SPA (console, dashboard, playground, integrations) served from the same sqlite database that `schema.prisma`, `init.sql` and `drizzle.config.ts` describe.
+Saddle is the 90-modality sandbox platform of the DevThink family: one engine spanning compute, virtualization, media, mesh, automation and the other modalities, exposed as a self-hosted site. This Sol theme is the platform's web surface — a Vite + React SPA (console, dashboard, playground, integrations) served from the same sqlite database that `schema.prisma`, `init.sql` and `drizzle.config.ts` describe.
 
 ```bash
 pnpm install