@qe-mcp/ena 0.1.18 → 0.1.20

package/README.md

@@ -176,22 +176,91 @@ A hosted server has no access to anyone's files, so this mode is a different
 privacy promise, and it says so to the model. In `--http` mode:
 
 - Data arrives inline as `data_csv`; `data_path` is refused. The server
-  processes it in memory and stores nothing.
-- `ena_profile`, `ena_tables`, `ena_lines` and `ena_export` are not offered
-  (they read or write files), and the prompts are not listed (they take a
-  path). Plots come back as the inline PNG plus the SVG as text; no files are
-  written.
+  parses it in memory and discards it when the call returns: no rows and no
+  CSV text are kept, in memory or on disk (locally, parsed rows are cached for
+  speed). What stays is the fitted model behind a `model_id` — points,
+  networks, unit labels and group values — for `$ENA_MCP_MODEL_TTL_MIN`
+  minutes after its last use (default 60), then it is forgotten.
+  `ena_simplify` refits, so hosted it takes `data_csv` again and checks that
+  it is the data the model was fitted on.
+- `ena_export` has nowhere to write, so it returns the ENA Web Tool project
+  ZIP inline, as a base64 resource in the result. The ZIP holds the data
+  file, which the server no longer has, so it takes `data_csv` again (checked
+  the same way) and keeps neither the data nor the ZIP afterwards. A client
+  that cannot save a file from a result asks for `format: "set"` instead: the
+  set file alone, which needs no data and sends none back; the summary says
+  how to pack it with the user's own data file. There is no download link,
+  not even a short-lived one, because that would mean keeping the data.
+- `ena_profile`, `ena_tables` and `ena_lines` are not offered (they read or
+  write files), and the prompts are not listed (they take a path). Plots come
+  back as the inline PNG plus the SVG as text; no files are written.
 - The server's instructions tell the model to say that the data leaves the
   user's machine and must be de-identified, and to get their OK first.
 - `model_id`s carry a random suffix so one conversation cannot plot another's
   model.
 
 Each request is answered statelessly, so any replica can take any request,
-but fitted models are cached in the process that fitted them: run one
-replica, or use sticky sessions, for `model_id`s to stay valid across calls.
+but fitted models live in the process that fitted them, until they expire:
+run one replica, or use sticky sessions, for `model_id`s to stay valid
+across calls.
 Put TLS and whatever authentication or rate limiting you need in front of it;
 the server itself does neither. `node test-http.mjs` starts it on a free port
-and checks all of the above.
+and checks all of the above; with `ENA_MCP_TEST_URL=http://host:port` it
+checks a server that is already running instead.
+
+#### Kubernetes
+
+The `Dockerfile` builds the server as `node server.js --http` on port 8000
+from the files the package ships plus production dependencies (no token
+needed: the `@qe-libs` packages resolve from a public registry endpoint).
+CI builds it for every main commit that touches those files and re-tags it
+with each `vX.Y.Z` release tag, at
+`registry.gitlab.com/epistemic-analytics/qe-packages/server-ena`.
+
+`inst/k8s/` is a Helm chart in the shape the other qe apps use: one replica
+with readiness and liveness on `/healthz`, and an nginx Ingress for
+`hostUrl` with a body limit above the server's, buffering off, and a
+per-client-IP rate limit (`rateLimit` in `values.yaml`: requests per second,
+burst, concurrent connections; over it nginx answers 503). The limiter keys
+on the address nginx sees, so it only tells clients apart if the controller
+takes the real client address from the load balancer; and all claude.ai
+users share Anthropic's egress addresses, so the defaults are generous.
+`ENA_MCP_MODEL_TTL_MIN` and `ENA_MCP_MAX_BODY_MB` come from the chart
+values. `inst/k8s/argo/production.yaml` is the Argo CD Application to copy
+into the argo-deployments repository; its image updater follows the
+semver image tags, so a release rolls out by itself.
+
+Locally:
+
+```bash
+docker build -t qe-mcp-ena . && docker run --rm -p 8000:8000 qe-mcp-ena
+ENA_MCP_TEST_URL=http://127.0.0.1:8000 node test-http.mjs
+```
+
+#### Cloudflare Workers
+
+The same server runs as a Worker, without Node. `worker/build.mjs` bundles it
+with esbuild into `worker/dist/`: the files the server reads from disk
+(fonts, the qeviz bundle, the skill text) are embedded, and the WASM modules
+are imported precompiled, as Workers require. Then wrangler runs or deploys
+it (Node 22 or newer for wrangler):
+
+```bash
+node worker/build.mjs
+cd worker && npx wrangler dev        # http://127.0.0.1:8787/mcp
+cd worker && npx wrangler deploy
+```
+
+Workers forbid `eval` and `new Function`, and Emscripten's Embind glue uses
+them unless the module was linked with `-sDYNAMIC_EXECUTION=0`:
+`@qe-libs/libqe-wasm` 0.2.4 and `@qe-libs/rena-wasm` 0.1.17 are the first
+builds linked that way. To test a locally built module instead,
+`ENA_WORKER_LIBQE_DIR` and `ENA_WORKER_LIBENA_DIR` name directories holding
+`libqe.js`/`libqe.wasm` and `libena.js`/`libena.wasm`. Fits need the Workers Paid plan (the free plan's
+10 ms CPU limit is too tight; a fit on 3,800 rows with its PNG takes a few
+hundred milliseconds). The model cache lives in the isolate that served the
+request, so `model_id`s stay valid only while the same isolate keeps
+answering; a shared store (KV or a Durable Object) would make them durable.
 
 ## Prompts
 

package/assets.js

@@ -0,0 +1,54 @@
+/**
+ * assets.js — the files the server reads from its own package.
+ *
+ * Node reads them from disk next to this file. A Worker bundle (see
+ * worker/) has no disk: it calls setAssets() with the same contents embedded
+ * at build time, before server.js is imported. Every accessor is lazy so the
+ * Node reads only happen when they are actually used.
+ */
+
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+// The bundled plot font (Inter, OFL), as paths for the native resvg and as
+// bytes for the WASM one.
+const FONT_FILES = ['Inter-Regular.ttf', 'Inter-Bold.ttf'];
+
+const nodeAssets = {
+    pkgJson: () => JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8')),
+    renaVersion() {
+        try { return JSON.parse(readFileSync(createRequire(import.meta.url).resolve('@qe-libs/rena-wasm/package.json'), 'utf8')).version; }
+        catch { return 'unknown'; }
+    },
+    // The qeviz UMD bundle, inlined into interactive pages.
+    qevizJS: () => readFileSync(createRequire(import.meta.url).resolve('@qe-libs/qeviz'), 'utf8'),
+    skillMarkdown() {
+        try { return readFileSync(new URL('./skill/ena-analysis/SKILL.md', import.meta.url), 'utf8'); }
+        catch { return null; }
+    },
+    // What @resvg/resvg-wasm's initWasm() accepts: bytes here, a compiled
+    // WebAssembly.Module in a Worker.
+    resvgWasm: () => readFileSync(createRequire(import.meta.url).resolve('@resvg/resvg-wasm/index_bg.wasm')),
+    fontPaths:   () => FONT_FILES.map(f => fileURLToPath(new URL(`./fonts/${f}`, import.meta.url))),
+    fontBuffers: () => FONT_FILES.map(f => readFileSync(new URL(`./fonts/${f}`, import.meta.url))),
+};
+
+let impl = nodeAssets;
+
+/** Replace the asset source (a Worker bundle does this before importing server.js). */
+export function setAssets(assets) { impl = { ...nodeAssets, ...assets }; }
+
+export const pkgJson       = () => impl.pkgJson();
+export const renaVersion   = () => impl.renaVersion();
+export const skillMarkdown = () => impl.skillMarkdown();
+export const resvgWasm     = () => impl.resvgWasm();
+export const fontPaths     = () => impl.fontPaths();
+export const fontBuffers   = () => impl.fontBuffers();
+
+let _qevizJS = null;
+export function qevizJS() {
+    // Drop the source-map comment: the .map file is not next to the inlined copy.
+    if (!_qevizJS) _qevizJS = String(impl.qevizJS()).replace(/\n\/\/# sourceMappingURL=\S*\s*$/, '\n');
+    return _qevizJS;
+}

package/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": "0.2",
   "name": "qe-mcp-ena",
   "display_name": "ENA — Epistemic Network Analysis",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Epistemic Network Analysis on tabular coded data. Runs entirely on your machine — data never leaves your computer.",
   "long_description": "Run Epistemic Network Analysis (ENA), ordered network analysis (ONA) and transmodal analysis (TMA) on your coded data from a conversation with Claude. No R or Python to install.\n\n**Your data stays on your machine**\n\n- The analysis runs locally. Only results — networks, points, statistics and plots — go back to the conversation.\n- Give Claude a file path rather than pasting data; the server reads the file itself.\n- It makes no network connections, starts no other programs, and writes files only when you ask for an export.\n\n**About the install warning**\n\nClaude Desktop shows \"access to everything on your computer\" for every extension outside Anthropic's reviewed directory. It means you are trusting the source, as with any program you install. The source is published on npm as @qe-mcp/ena.\n\nDocumentation and example prompts: https://qe-libs.org/mcp/qe-mcp-ena/",
   "author": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qe-mcp/ena",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Epistemic Network Analysis for Claude and other assistants — runs on your machine",
   "repository": {
     "type": "git",
@@ -13,6 +13,7 @@
   },
   "files": [
     "server.js",
+    "assets.js",
     "webena.js",
     "xlsx.js",
     "lines.js",
@@ -27,7 +28,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.4.0",
     "@qe-libs/qeviz": "0.7.0",
-    "@qe-libs/rena-wasm": "^0.1.14",
+    "@qe-libs/rena-wasm": "^0.1.17",
     "@resvg/resvg-wasm": "^2.6.2"
   },
   "optionalDependencies": {
@@ -39,5 +40,8 @@
     "epistemic-network-analysis",
     "wasm"
   ],
-  "license": "GPL-3.0-only"
+  "license": "GPL-3.0-only",
+  "devDependencies": {
+    "wrangler": "^4.156.0"
+  }
 }

package/server.js

@@ -41,7 +41,8 @@ import { randomBytes } from 'crypto';
 // written to files, and the file-based tools are not offered.
 const ARGV   = process.argv.slice(2);
 const argOf  = (flag, dflt) => { const i = ARGV.indexOf(flag); return i >= 0 && ARGV[i + 1] != null ? ARGV[i + 1] : dflt; };
-const REMOTE = ARGV.includes('--http');
+// Embedded in a Worker (globalThis.ENA_MCP_EMBEDDED) is always the hosted mode.
+const REMOTE = ARGV.includes('--http') || !!globalThis.ENA_MCP_EMBEDDED;
 const HTTP_PORT = Number(argOf('--port', process.env.PORT ?? 8000));
 const HTTP_HOST = argOf('--host', process.env.HOST ?? '127.0.0.1');
 const HTTP_PATH = '/mcp';
@@ -53,8 +54,9 @@ if (ARGV.includes('--help') || ARGV.includes('-h')) {
         '',
         '  (no flags)   MCP over stdio — what Claude Desktop, Claude Code and other local clients run.',
         '  --http       MCP over streamable HTTP at /mcp, for hosting. Data must be passed inline',
-        '               (data_csv); nothing is written to disk; ena_profile, ena_tables, ena_lines and',
-        '               ena_export are not offered. Health check: GET /healthz.',
+        '               (data_csv) and is discarded after each call; only fitted models are kept, for',
+        '               $ENA_MCP_MODEL_TTL_MIN minutes (default 60); nothing is written to disk; ena_profile,',
+        '               ena_tables and ena_lines are not offered; ena_export returns the ZIP inline. Health check: GET /healthz.',
         '  --port N     Port for --http (default: $PORT or 8000).',
         '  --host H     Interface for --http (default: $HOST or 127.0.0.1; use 0.0.0.0 in a container).',
         '  --max-body-mb N  Largest request body in MB (default: $ENA_MCP_MAX_BODY_MB or 25).',
@@ -73,17 +75,9 @@ import loadENA, { detectParams, isBinary } from '@qe-libs/rena-wasm';
 // qeviz: renderSVG() draws the static plot here, with no DOM; the UMD bundle
 // (self-contained, no external deps) is inlined into the interactive page.
 import { renderSVG as qevizRenderSVG } from '@qe-libs/qeviz';
-import { createRequire } from 'module';
-const _require = createRequire(import.meta.url);
-const QEVIZ_BUNDLE = _require.resolve('@qe-libs/qeviz');
-let _qevizJS = null;
-function qevizJS() {
-    // The bundle is inlined into pages, so drop its source-map comment
-    // (the .map file is not next to the inlined copy).
-    if (!_qevizJS) _qevizJS = readFileSync(QEVIZ_BUNDLE, 'utf8')
-        .replace(/\n\/\/# sourceMappingURL=\S*\s*$/, '\n');
-    return _qevizJS;
-}
+// Package files (qeviz bundle, fonts, skill text, versions): read from disk
+// in Node, embedded at build time in a Worker (see assets.js).
+import { qevizJS, pkgJson, renaVersion, skillMarkdown, resvgWasm, fontBuffers, fontPaths } from './assets.js';
 
 // ── CSV parser ────────────────────────────────────────────────────────────────
 
@@ -388,7 +382,7 @@ function buildGmrParams(rows, unitCols, unitLabels, p) {
 // rotationSet (= R's rotation.set): centred on the source's centerVec, rotated
 // by its rotation matrix, with its node positions.
 function rotationSetFrom(sourceId, codes, ordered) {
-    const src = cacheGet(modelCache, sourceId);
+    const src = modelGet(sourceId);
     if (!src)
         throw new Error(`rotation_from: unknown model_id '${sourceId}'. Fit the source model first ` +
             `(the ${MAX_MODELS} most recently used models are kept).`);
@@ -688,30 +682,41 @@ function vizSlug(result, args = {}) {
 // ── static SVG renderer ───────────────────────────────────────────────────────
 
 // PNG output (the inline image block and the png_plot file) prefers the native
-// @resvg/resvg-js, an OPTIONAL dependency: fastest, and it reads system fonts.
-// Where it is absent — the cross-platform .mcpb bundle, or a platform without a
-// prebuilt binary — @resvg/resvg-wasm renders the same image. It cannot see
-// system fonts, so plot labels are drawn with the bundled Inter (fonts/, OFL).
+// @resvg/resvg-js, an OPTIONAL dependency: fastest. Where it is absent — the
+// cross-platform .mcpb bundle, or a platform without a prebuilt binary —
+// @resvg/resvg-wasm renders the same image. Both draw plot labels with the
+// bundled Inter (fonts/, OFL) and never scan system fonts: resvg's default
+// loadSystemFonts walks the whole system font set on EVERY render, which on
+// macOS costs ~1.5 s per PNG against ~25 ms with the two bundled files.
 // Loaded lazily; if neither loads, SVG and interactive HTML are still produced.
+//
+// The two builds take the fonts differently. The WASM build takes the bytes
+// (fontBuffers). The native build takes paths (fontFiles): given fontBuffers,
+// resvg-js 2.6 scans the system fonts anyway, loadSystemFonts: false or not,
+// and the 1.5 s is back.
+const FONT_FAMILY = { defaultFontFamily: 'Inter', sansSerifFamily: 'Inter', loadSystemFonts: false };
+// Wrap a Resvg class so every render uses the bundled fonts and asPng() yields
+// a Buffer (the WASM build returns a Uint8Array).
+function withBundledFonts(Resvg, fonts) {
+    let font;
+    return function FontedResvg(svg, opts = {}) {
+        font ??= { ...FONT_FAMILY, ...fonts() };
+        const r = new Resvg(svg, { ...opts, font: { ...font, ...opts.font } });
+        return { render: () => { const img = r.render(); return { asPng: () => Buffer.from(img.asPng()) }; } };
+    };
+}
 let _Resvg;   // undefined = not yet attempted; null = unavailable
 async function getResvg() {
     if (_Resvg !== undefined) return _Resvg;
     try {
-        ({ Resvg: _Resvg } = await import('@resvg/resvg-js'));
+        const { Resvg } = await import('@resvg/resvg-js');
+        _Resvg = withBundledFonts(Resvg, () => ({ fontFiles: fontPaths() }));
         return _Resvg;
     } catch { /* fall back to WASM */ }
     try {
         const { initWasm, Resvg } = await import('@resvg/resvg-wasm');
-        await initWasm(readFileSync(_require.resolve('@resvg/resvg-wasm/index_bg.wasm')));
-        const fontBuffers = ['Inter-Regular.ttf', 'Inter-Bold.ttf']
-            .map(f => readFileSync(new URL(`./fonts/${f}`, import.meta.url)));
-        const font = { fontBuffers, defaultFontFamily: 'Inter', sansSerifFamily: 'Inter' };
-        // Same shape as the native class — new Resvg(svg, opts).render().asPng()
-        // — but asPng() gives a Uint8Array here, so hand back a Buffer as native does.
-        _Resvg = function WasmResvg(svg, opts = {}) {
-            const r = new Resvg(svg, { ...opts, font });
-            return { render: () => { const img = r.render(); return { asPng: () => Buffer.from(img.asPng()) }; } };
-        };
+        await initWasm(await resvgWasm());
+        _Resvg = withBundledFonts(Resvg, () => ({ fontBuffers: fontBuffers() }));
     } catch (e) {
         _Resvg = null;
         process.stderr.write(
@@ -849,6 +854,18 @@ let   modelSeq   = 0;
 const MAX_ACCUM  = 8;
 const MAX_MODELS = 50;
 
+// Hosted, the process serves strangers, so it keeps no data: parsed rows and
+// accumulations are not cached (every call re-parses the CSV it was sent, tens
+// of ms), the CSV text is dropped from a model's stored parameters, and a
+// model — points, networks, unit and group labels — is forgotten MODEL_TTL_MS
+// after its last use instead of waiting to be displaced.
+const KEEP_ROWS = !REMOTE;
+const EXPORT_HINT = REMOTE
+    ? 'or ena_export (with data_csv again, or format="set") for an ENA Web Tool project.'
+    : 'or ena_export to open the model in the ENA Web Tool.';
+let MODEL_TTL_MS = REMOTE ? Number(process.env.ENA_MCP_MODEL_TTL_MIN ?? 60) * 60_000 : 0;
+export function setModelTtl(minutes) { MODEL_TTL_MS = Number(minutes) * 60_000; }
+
 function cacheGet(map, key) {
     if (!map.has(key)) return undefined;
     const v = map.get(key);
@@ -861,6 +878,27 @@ function cacheSet(map, key, value, max) {
     while (map.size > max) map.delete(map.keys().next().value);
 }
 
+function expireModels(now = Date.now()) {
+    if (!MODEL_TTL_MS) return;
+    for (const [id, e] of modelCache)
+        if (now - e._used > MODEL_TTL_MS) modelCache.delete(id);
+}
+function modelGet(model_id) {
+    expireModels();
+    const e = cacheGet(modelCache, model_id);
+    if (e) e._used = Date.now();
+    return e;
+}
+function modelSet(model_id, entry) {
+    expireModels();
+    if (!KEEP_ROWS && entry.params) {
+        entry._data  = dataStamp(entry.params);   // to check resent data against
+        entry.params = { ...entry.params, data_csv: undefined };
+    }
+    entry._used = Date.now();
+    cacheSet(modelCache, model_id, entry, MAX_MODELS);
+}
+
 // Identifies the input data. For a file, include its mtime and size so an
 // edited CSV is re-read instead of serving a model fitted on the old contents.
 function dataStamp(p) {
@@ -1027,13 +1065,13 @@ function loadRows(p) {
     const key = dataStamp(p);
     let rows;
     if (rowsCache.has(key)) rows = cacheGet(rowsCache, key);
-    else { rows = loadData(p.data_path, p.data_csv); cacheSet(rowsCache, key, rows, MAX_ROWS); }
+    else { rows = loadData(p.data_path, p.data_csv); if (KEEP_ROWS) cacheSet(rowsCache, key, rows, MAX_ROWS); }
     if (!toArray(p.exclude_conversations).length && !p.order_by) return rows;
 
     const vKey = JSON.stringify([key, toArray(p.conversations), toArray(p.exclude_conversations), p.order_by ?? null]);
     if (rowsCache.has(vKey)) return cacheGet(rowsCache, vKey);
     const view = prepareRows(rows, p);
-    cacheSet(rowsCache, vKey, view, MAX_ROWS);
+    if (KEEP_ROWS) cacheSet(rowsCache, vKey, view, MAX_ROWS);
     return view;
 }
 
@@ -1437,7 +1475,7 @@ async function toolTmaFit(ena, params) {
         result,
     };
     entry.view = defaultView(params, entry.web);
-    cacheSet(modelCache, model_id, entry, MAX_MODELS);
+    modelSet(model_id, entry);
 
     return { ...result, _plot: web.buildPlot(entry, entry.view) };
 }
@@ -1700,9 +1738,9 @@ async function toolFit(ena, params) {
     // Return cached model if params are identical
     const fKey = fitCacheKey(params);
     const cachedId = fitCache.get(fKey);
-    if (cachedId && modelCache.has(cachedId)) {   // the model may have been evicted
-        const model_id = cachedId;
-        const entry    = cacheGet(modelCache, model_id);
+    const cached = cachedId && modelGet(cachedId);   // the model may have been evicted or expired
+    if (cached) {
+        const model_id = cachedId, entry = cached;
         return {
             model_id,
             ...entry.result,
@@ -1722,7 +1760,7 @@ async function toolFit(ena, params) {
             codes, units: unitCols, conversations: convoCols,
             window: windowValue(window_size), binary, ...accumOpts(params),
         });
-        cacheSet(accumCache, aKey, { rows, acc }, MAX_ACCUM);
+        if (KEEP_ROWS) cacheSet(accumCache, aKey, { rows, acc }, MAX_ACCUM);
     }
 
     const { unitLabels, nConnections, connectionNames, nUnits } = acc;
@@ -1792,7 +1830,7 @@ async function toolFit(ena, params) {
         ...(tests ? ['', ...tests.lines] : []),
         '',
         `Use ena_plot with model_id="${model_id}" for additional views (group, unit, subtraction, comparison), ` +
-            `or ena_export to open the model in the ENA Web Tool.`,
+            EXPORT_HINT,
     ].join('\n');
 
     const result = {
@@ -1822,7 +1860,7 @@ async function toolFit(ena, params) {
         result,
     };
     entry.view = defaultView(params, entry.web);
-    cacheSet(modelCache, model_id, entry, MAX_MODELS);
+    modelSet(model_id, entry);
     cacheSet(fitCache, fKey, model_id, MAX_MODELS);
 
     return { ...result, _plot: web.buildPlot(entry, entry.view) };
@@ -1943,9 +1981,9 @@ async function toolCompareGroups(ena, params) {
     // Return cached model if params are identical
     const fKey = fitCacheKey(params, 'compare');
     const cachedId = fitCache.get(fKey);
-    if (cachedId && modelCache.has(cachedId)) {   // the model may have been evicted
-        const model_id = cachedId;
-        const entry    = cacheGet(modelCache, model_id);
+    const cached = cachedId && modelGet(cachedId);   // the model may have been evicted or expired
+    if (cached) {
+        const model_id = cachedId, entry = cached;
         return {
             model_id,
             ...entry.result,
@@ -1969,7 +2007,7 @@ async function toolCompareGroups(ena, params) {
             codes, units: unitCols, conversations: convoCols,
             window: windowValue(window_size), binary, ...accumOpts(params),
         });
-        cacheSet(accumCache, aKey, { rows, acc }, MAX_ACCUM);
+        if (KEEP_ROWS) cacheSet(accumCache, aKey, { rows, acc }, MAX_ACCUM);
     }
 
     const { unitLabels, connectionNames, nUnits, nConnections } = acc;
@@ -2064,7 +2102,7 @@ async function toolCompareGroups(ena, params) {
         ),
         '',
         `Use ena_plot with model_id="${model_id}" for group, subtraction, comparison, or unit views, ` +
-            `or ena_export to open the model in the ENA Web Tool.`,
+            EXPORT_HINT,
     ].join('\n');
 
     const result = {
@@ -2101,7 +2139,7 @@ async function toolCompareGroups(ena, params) {
         result,
     };
     entry.view = defaultView(params, entry.web);
-    cacheSet(modelCache, model_id, entry, MAX_MODELS);
+    modelSet(model_id, entry);
     cacheSet(fitCache, fKey, model_id, MAX_MODELS);
 
     return { ...result, _plot: web.buildPlot(entry, entry.view) };
@@ -2180,7 +2218,7 @@ async function toolPlot({ model_id, type = 'all', group_value, group1, group2, u
                           x_dim = 1, y_dim = 2, flip_x = false, flip_y = false,
                           min_edge_weight, hide_unconnected_codes, text_size, colors,
                           confidence_intervals, outlier_intervals }) {
-    const entry = cacheGet(modelCache, model_id);
+    const entry = modelGet(model_id);
     if (!entry)
         throw new Error(`Unknown model_id '${model_id}'. Call ena_fit, ena_compare_groups or tma_fit first ` +
             `(the ${MAX_MODELS} most recently used models are kept; refitting is cheap).`);
@@ -2354,7 +2392,7 @@ function csvCell(v) {
 const csvText = (header, rows) => [header, ...rows].map(r => r.map(csvCell).join(',')).join('\n') + '\n';
 
 async function toolTables(ena, { model_id, out_path }) {
-    const entry = cacheGet(modelCache, model_id);
+    const entry = modelGet(model_id);
     if (!entry)
         throw new Error(`Unknown model_id '${model_id}'. Fit the model first (ena_fit, ena_compare_groups or tma_fit).`);
     const { model, codes, unitLabels } = entry;
@@ -2409,12 +2447,20 @@ async function toolTables(ena, { model_id, out_path }) {
 // then, as the web tool does, refit without the removed codes.
 const PRIA_MIN = 0.8, PRIA_MAX = 0.99;
 
-async function toolSimplify(ena, { model_id, threshold = 0.95, remove_num = 3 }) {
-    const entry = cacheGet(modelCache, model_id);
+async function toolSimplify(ena, { model_id, threshold = 0.95, remove_num = 3, data_csv }) {
+    const entry = modelGet(model_id);
     if (!entry)
         throw new Error(`Unknown model_id '${model_id}'. Fit the model first (ena_fit, ena_compare_groups or tma_fit).`);
     if (!entry.fitArgs) throw new Error(`Model ${model_id} can't be simplified. Refit it with this server version.`);
-    const p = entry.params ?? {};
+    let p = entry.params ?? {};
+    if (!KEEP_ROWS) {
+        // The hosted server kept nothing but the model: PRIA refits, so the
+        // same data must come again, and it must be the same data.
+        if (!data_csv) throw new Error('Hosted server: the data is not stored. Pass data_csv again (the CSV the model was fitted on).');
+        if (dataStamp({ data_csv }) !== entry._data)
+            throw new Error(`data_csv is not the data model ${model_id} was fitted on. Pass the same CSV, or fit a new model.`);
+        p = { ...p, data_csv };
+    }
     const codes = entry.codes;
     if (codes.length < 4)
         throw new Error(`Model ${model_id} has ${codes.length} codes; PRIA needs more than 3 (it never leaves fewer than 3).`);
@@ -2461,7 +2507,7 @@ async function toolSimplify(ena, { model_id, threshold = 0.95, remove_num = 3 })
 const DEFAULT_MAX_WINDOWS = 500;
 
 async function toolLines(ena, { model_id, connection, units, group, columns, max_windows, out_path }) {
-    const entry = cacheGet(modelCache, model_id);
+    const entry = modelGet(model_id);
     if (!entry)
         throw new Error(`Unknown model_id '${model_id}'. Fit the model first (ena_fit, ena_compare_groups or tma_fit).`);
     const { model, codes, unitLabels } = entry;
@@ -2595,8 +2641,8 @@ async function toolLines(ena, { model_id, connection, units, group, columns, max
     };
 }
 
-async function toolExport(ena, { model_id, set_name, out_path }) {
-    const entry = cacheGet(modelCache, model_id);
+async function toolExport(ena, { model_id, set_name, out_path, data_csv, format }) {
+    const entry = modelGet(model_id);
     if (!entry)
         throw new Error(`Unknown model_id '${model_id}'. Fit the model first (ena_fit, ena_compare_groups or tma_fit).`);
     const blockers = exportBlockers(entry);
@@ -2604,9 +2650,34 @@ async function toolExport(ena, { model_id, set_name, out_path }) {
         throw new Error(`Model ${model_id} can't be exported to the ENA Web Tool, which has no setting for: ${blockers.join('; ')}. ` +
             'Refit without these to export it.');
 
-    const p = entry.params;
+    let p = entry.params;
+    if (KEEP_ROWS) {
+        format = 'zip';
+    } else {
+        // The hosted server kept nothing but the model. The project ZIP holds
+        // the data file, so the data must come again (and be the same data);
+        // the set file alone needs no data unless the set stores excluded
+        // units or conversations, which are read from the rows.
+        format = format ?? 'zip';
+        if (format !== 'zip' && format !== 'set')
+            throw new Error('format must be "zip" (the project ZIP, which needs data_csv again) or "set" (the set file alone).');
+        if (data_csv) {
+            if (dataStamp({ data_csv }) !== entry._data)
+                throw new Error(`data_csv is not the data model ${model_id} was fitted on. Pass the same CSV, or fit a new model.`);
+            p = { ...p, data_csv };
+        } else if (format === 'zip') {
+            throw new Error('Hosted server: the data is not stored. Pass data_csv again (the CSV the model was fitted on) to build the ZIP, ' +
+                'or format="set" for the set file alone.');
+        }
+    }
     const unitCols = toArray(p.units);
     const warnings = [];
+    let _rows = null;
+    const fileRows = (why) => {
+        if (!p.data_path && p.data_csv == null)
+            throw new Error(`Hosted server: this set needs the rows (${why}). Pass data_csv again (the CSV the model was fitted on).`);
+        return _rows ??= loadRows({ data_path: p.data_path, data_csv: p.data_csv });
+    };
 
     // The web tool groups units by their first unit column; take that column's
     // groups (order, colours) for the stored set.
@@ -2617,8 +2688,7 @@ async function toolExport(ena, { model_id, set_name, out_path }) {
         if (entry.groupCol === groupCol) {
             groups = entry.web.groups.map(g => ({ name: g.name, color: g.color, secondaryColor: g.secondaryColor, showMean: g.showMean }));
         } else {
-            const rows = loadRows(p);
-            groups = web.groupOrder(rows, groupCol).map((name, i) => ({ name, ...web.groupStyle(i) }));
+            groups = web.groupOrder(fileRows(`the ${groupCol} groups`), groupCol).map((name, i) => ({ name, ...web.groupStyle(i) }));
             if (entry.groupCol)
                 warnings.push(`The web tool groups units by ${groupCol}, so its plots show ${groupCol} groups, not ${entry.groupCol}.`);
         }
@@ -2633,9 +2703,6 @@ async function toolExport(ena, { model_id, set_name, out_path }) {
 
     // The web tool's project holds a CSV; an .xlsx goes in as its first sheet.
     const csvName = p.data_path ? basename(p.data_path).replace(/\.xlsx$/i, '.csv') : 'data.csv';
-    const csv = p.data_path
-        ? (isXlsx(p.data_path) ? Buffer.from(dataFileText(p.data_path), 'utf8') : readFileSync(p.data_path))
-        : Buffer.from(p.data_csv ?? '', 'utf8');
     const setName = safeFileName(set_name ??
         (plotted.secondary ? `${plotted.primary} vs ${plotted.secondary}` : `ENA model ${model_id}`));
 
@@ -2644,7 +2711,6 @@ async function toolExport(ena, { model_id, set_name, out_path }) {
     // Built from the whole file: the web tool applies exclude_conversations
     // and order_by itself (WasmWrapper._modelRowIndices), on the data file the
     // ZIP carries unchanged.
-    const fileRows = loadRows({ data_path: p.data_path, data_csv: p.data_csv });
     const exclConvos = toArray(p.exclude_conversations).map(e => String(e).split('__').join('::'));
     let unitTree = null, excluded = 0;
     if (p.units_used?.length || exclConvos.length) {
@@ -2653,7 +2719,7 @@ async function toolExport(ena, { model_id, set_name, out_path }) {
         // rebuilds the conversation tree, which drops its include flags.
         const used = p.units_used?.length ? new Set(p.units_used.map(String)) : null;
         const seen = new Map();
-        for (const r of fileRows) {
+        for (const r of fileRows('excluded units')) {
             const values = unitCols.map(c => String(r[c]));
             const key = values.join('__');
             if (!seen.has(key)) seen.set(key, { values, include: used ? used.has(key) : true });
@@ -2666,7 +2732,7 @@ async function toolExport(ena, { model_id, set_name, out_path }) {
         const convoCols = toArray(p.conversations);
         const out = new Set(exclConvos);
         const seen = new Map();
-        for (const r of fileRows) {
+        for (const r of fileRows('excluded conversations')) {
             const values = convoCols.map(c => String(r[c]));
             const key = values.join('::');
             if (!seen.has(key)) seen.set(key, { values, include: !out.has(key) });
@@ -2690,19 +2756,6 @@ async function toolExport(ena, { model_id, set_name, out_path }) {
         source: { tool: PKG.name, version: PKG.version, model_id, exported: new Date().toISOString() },
     });
 
-    const zipBuf = web.zip([
-        { name: csvName, data: csv },
-        { name: 'Folder/' },
-        { name: `Folder/${setName}.json`, data: JSON.stringify(set, null, 2) },
-    ]);
-
-    let target = out_path
-        ? (extname(out_path).toLowerCase() === '.zip' ? out_path : join(out_path, `${setName}.zip`))
-        : join(p.data_path ? dirname(p.data_path) : VIZ_DIR, `${setName}.zip`);
-    target = freePath(target);
-    mkdirSync(dirname(target), { recursive: true });
-    writeFileSync(target, zipBuf);
-
     const rot = set.settings.model;
     const settings = {
         units: unitCols, conversations: toArray(p.conversations), codes: entry.codes,
@@ -2717,14 +2770,82 @@ async function toolExport(ena, { model_id, set_name, out_path }) {
         ...(p.order_by && { order_by: p.order_by }),
         ...(toArray(p.mask_connections).length && { masked_connections: toArray(p.mask_connections) }),
     };
+    const howToOpen = [
+        'To open it: start a local session in the ENA Web Tool ("Run Offline"), click Import in the Sets panel,',
+        `choose the ZIP, then open Folder › ${setName}. (Project import works in local sessions only.)`,
+    ];
+
+    if (format === 'set') {
+        // Hosted, without the data: the set file alone. The user packs the
+        // project themselves, so their data never has to come back here.
+        return {
+            set_name: setName,
+            data_file: csvName,
+            set_file: `Folder/${setName}.json`,
+            set,
+            settings,
+            warnings,
+            privacy_note: 'Hosted server: this is the set file only — settings, groups and labels, no rows. Nothing was stored.',
+            summary: [
+                `Set file for model ${model_id} (ENA Web Tool), without the data.`,
+                `  Set: Folder / ${setName}   Opens with: ${settings.opens_with}`,
+                ...warnings.map(w => `  Note: ${w}`),
+                '',
+                'To make the project ZIP: save the "set" field as JSON at Folder/' + setName + '.json, put the data file',
+                `the model was fitted on beside it as ${csvName} (that exact name), and zip the two —`,
+                `the ZIP holds ${csvName} and Folder/${setName}.json.`,
+                ...howToOpen,
+            ].join('\n'),
+        };
+    }
+
+    const csv = p.data_path
+        ? (isXlsx(p.data_path) ? Buffer.from(dataFileText(p.data_path), 'utf8') : readFileSync(p.data_path))
+        : Buffer.from(p.data_csv ?? '', 'utf8');
+    const zipBuf = web.zip([
+        { name: csvName, data: csv },
+        { name: 'Folder/' },
+        { name: `Folder/${setName}.json`, data: JSON.stringify(set, null, 2) },
+    ]);
+
+    if (!KEEP_ROWS) {
+        // Hosted: nowhere to write, so the ZIP rides along with the result as
+        // an embedded resource (base64). Nothing of it stays on the server.
+        return {
+            _zip: { name: `${setName}.zip`, data: zipBuf },
+            zip_file: `${setName}.zip`,
+            zip_bytes: zipBuf.length,
+            set_name: setName,
+            data_file: csvName,
+            settings,
+            warnings,
+            privacy_note: 'Hosted server: the ZIP holds the data sent with this call. The server kept neither the data nor the ZIP.',
+            summary: [
+                `Exported model ${model_id} as an ENA Web Tool project ZIP: ${setName}.zip (${zipBuf.length} bytes), ` +
+                    'attached to this result as a base64 resource (application/zip). Save it as a .zip file.',
+                `  Set: Folder / ${setName}   Data: ${csvName}`,
+                `  Opens with: ${settings.opens_with}`,
+                ...warnings.map(w => `  Note: ${w}`),
+                '',
+                ...howToOpen,
+            ].join('\n'),
+        };
+    }
+
+    let target = out_path
+        ? (extname(out_path).toLowerCase() === '.zip' ? out_path : join(out_path, `${setName}.zip`))
+        : join(p.data_path ? dirname(p.data_path) : VIZ_DIR, `${setName}.zip`);
+    target = freePath(target);
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, zipBuf);
+
     const summary = [
         `Exported model ${model_id} as an ENA Web Tool project: ${target}`,
         `  Set: Folder / ${setName}   Data: ${csvName}`,
         `  Opens with: ${settings.opens_with}`,
         ...warnings.map(w => `  Note: ${w}`),
         '',
-        'To open it: start a local session in the ENA Web Tool ("Run Offline"), click Import in the Sets panel,',
-        `choose the ZIP, then open Folder › ${setName}. (Project import works in local sessions only.)`,
+        ...howToOpen,
     ].join('\n');
 
     return {
@@ -2793,8 +2914,8 @@ const ROTATION_PROPS = {
 
 const GUIDE = (() => {
     let md;
-    try { md = readFileSync(new URL('./skill/ena-analysis/SKILL.md', import.meta.url), 'utf8'); }
-    catch { return null; }
+    md = skillMarkdown();
+    if (md == null) return null;
     md = md.replace(/^---\n[\s\S]*?\n---\n+/, '');                 // frontmatter
     const sections = [];
     for (const part of md.split(/^(?=## )/m).slice(1)) {
@@ -2812,7 +2933,8 @@ function toolGuide({ topic } = {}) {
     const header = REMOTE
         ? '> **Hosted server.** This server runs remotely, not on the user\'s machine. Where the guide says to pass ' +
           'data_path, pass the data inline as data_csv instead, after the user confirms it is de-identified. ' +
-          'ena_profile, ena_tables, ena_lines and ena_export are not available here; plots come back inline.\n\n'
+          'ena_profile, ena_tables and ena_lines are not available here; plots come back inline, and ena_export returns ' +
+          'the project ZIP inline (with data_csv again) or the set file alone (format="set").\n\n'
         : '';
     if (!topic) return header + GUIDE.text + footer;
     const t = String(topic).toLowerCase().trim();
@@ -3111,6 +3233,7 @@ const TOOLS = [
                 model_id:   { type: 'string', description: 'model_id from ena_fit, ena_compare_groups or tma_fit' },
                 threshold:  { type: 'number', minimum: 0.8, maximum: 0.99, description: 'How close the simplified model must stay to the full one (default 0.95; the web tool allows 0.80–0.99).' },
                 remove_num: { type: 'integer', minimum: 1, description: 'Most codes to remove (default 3).' },
+                data_csv:   { type: 'string', description: 'Hosted server only: the CSV the model was fitted on, again (the server does not store it). Locally, omit.', _hostedOnly: true },
             },
             required: ['model_id'],
         },
@@ -3164,13 +3287,16 @@ const TOOLS = [
             'it rebuilds the same model and opens on the same comparison plot. ' +
             'Excluded units (units_used) are stored as excluded in the web tool\'s Units tab. Models the web tool has no setting for (transmodal or time windows, a GMR on x_var, rotations by a column other than the first unit column, ' +
             'center_align_to_origin=false) are refused with the reason. ' +
-            'PRIVACY: the ZIP contains the data file. It is written locally (by default next to the data file, never overwriting one) and no rows are sent to Claude.',
+            'PRIVACY: the ZIP contains the data file. It is written locally (by default next to the data file, never overwriting one) and no rows are sent to Claude. ' +
+            'HOSTED: there is no disk; the ZIP comes back inline, built from data_csv sent again with the call, or format="set" returns the set file alone for the user to pack with their own data file.',
         inputSchema: {
             type: 'object',
             properties: {
                 model_id: { type: 'string', description: 'model_id of the model to export' },
                 set_name: { type: 'string', description: 'Name of the set in the web tool (default: "<group 1> vs <group 2>", or "ENA model <id>")' },
-                out_path: { type: 'string', description: 'Where to write: a .zip path, or a folder. Default: the data file\'s folder, as "<set name>.zip" (a number is added rather than overwrite).' },
+                out_path: { type: 'string', description: 'Where to write: a .zip path, or a folder. Default: the data file\'s folder, as "<set name>.zip" (a number is added rather than overwrite).', _localOnly: true },
+                format:   { type: 'string', enum: ['zip', 'set'], description: 'Hosted server only. "zip" (default): the project ZIP, returned inline as a base64 resource; needs data_csv again. "set": the set file alone (no data needed, nothing sent back but settings); the user packs it with their own data file as the summary says. Locally, omit.', _hostedOnly: true },
+                data_csv: { type: 'string', description: 'Hosted server only: the CSV the model was fitted on, again (the server does not store it). Required for format "zip". Locally, omit.', _hostedOnly: true },
             },
             required: ['model_id'],
         },
@@ -3180,13 +3306,14 @@ const TOOLS = [
 // Hosted: no user files to read or write, so the file tools go, data_path goes
 // from every schema, and the privacy wording changes from "keep it local" to
 // "send it de-identified".
-const REMOTE_HIDDEN_TOOLS = new Set(['ena_profile', 'ena_tables', 'ena_lines', 'ena_export']);
-const REMOTE_PRIVACY = 'PRIVACY (hosted server): the data is sent inline and processed in memory; it is not stored. ' +
+const REMOTE_HIDDEN_TOOLS = new Set(['ena_profile', 'ena_tables', 'ena_lines']);
+const REMOTE_PRIVACY = 'PRIVACY (hosted server): the data is sent inline and processed in memory; it is discarded when the call returns, and only the fitted model is kept, for a limited time. ' +
     'Before sending it, confirm with the user that it is de-identified. ';
 function remoteTools(tools) {
     return tools.filter(t => !REMOTE_HIDDEN_TOOLS.has(t.name)).map(t => {
-        const { data_path, ...properties } = t.inputSchema.properties ?? {};
+        const { data_path, ...properties } = Object.fromEntries(Object.entries(t.inputSchema.properties ?? {}).filter(([, v]) => !v._localOnly));
         let description = t.description
+            .replace(/ ?It is written locally[^.]*\. HOSTED: /, ' Hosted: ')
             .replace(/The ENA network plot is written to disk[^]*?Use these paths to show the plot; /,
                      'The ENA network plot comes back as an inline image. Use it to show the plot; ')
             .replace(/The ENA network plot is written to disk[^]*?is installed\./,
@@ -3197,25 +3324,32 @@ function remoteTools(tools) {
             .replace(/If the user has not yet indicated whether their data is sensitive, ask before using data_csv\. ?/, '')
             .replace(/If they indicate sensitivity, use ena_profile instead \(no raw data transmitted\)\. ?/, '')
             .trim();
+        for (const [k, v] of Object.entries(properties)) if (v._hostedOnly) { const { _hostedOnly, ...d } = v; properties[k] = d; }
         const required = (t.inputSchema.required ?? []).filter(r => r !== 'data_path');
         if (properties.data_csv && !description.includes(REMOTE_PRIVACY.trim()))
             description = `${description} ${REMOTE_PRIVACY.trim()}`;
-        if (properties.data_csv) properties.data_csv = {
+        if (properties.data_csv && !properties.data_csv._hostedOnly) properties.data_csv = {
             type: 'string',
             description: 'The data as CSV text. The server has no access to the user\'s files; it processes this in memory and does not store it. Send only de-identified data.',
         };
+        if (properties.data_csv?._hostedOnly) { const { _hostedOnly, ...d } = properties.data_csv; properties.data_csv = d; }
         return { ...t, description, inputSchema: { ...t.inputSchema, properties, ...(required.length ? { required } : {}) } };
     });
 }
-const OFFERED_TOOLS = REMOTE ? remoteTools(TOOLS) : TOOLS;
+function localTools(tools) {
+    return tools.map(t => {
+        const properties = Object.fromEntries(Object.entries(t.inputSchema.properties ?? {}).filter(([, v]) => !v._hostedOnly)
+            .map(([k, { _localOnly, ...v }]) => [k, v]));
+        const description = t.description.replace(/ HOSTED: .*$/, '');
+        return { ...t, description, inputSchema: { ...t.inputSchema, properties } };
+    });
+}
+const OFFERED_TOOLS = REMOTE ? remoteTools(TOOLS) : localTools(TOOLS);
 
 // ── Server setup ──────────────────────────────────────────────────────────────
 
-const PKG = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8'));
-const RENA_VERSION = (() => {
-    try { return JSON.parse(readFileSync(_require.resolve('@qe-libs/rena-wasm/package.json'), 'utf8')).version; }
-    catch { return 'unknown'; }
-})();
+const PKG = pkgJson();
+const RENA_VERSION = renaVersion();
 // Stamped on every result and plot, so results from this server can be told
 // apart from anything computed in the conversation.
 const PROVENANCE = `${PKG.name} ${PKG.version} (rena-wasm ${RENA_VERSION})`;
@@ -3249,14 +3383,16 @@ function withholdDataValues(msg, args) {
 
 // Sent to the client at connection; MCP clients (Claude, Codex, Gemini CLI,
 // Cursor, ...) pass it to the model, so the privacy rule reaches every one.
-const SERVER_INSTRUCTIONS = REMOTE ? [
+const serverInstructions = () => REMOTE ? [
     'ENA / ONA / TMA analysis on a hosted server. The server does not run on the user\'s machine and cannot read their files.',
     '',
     'Data privacy — follow in every conversation:',
-    '- Data reaches these tools inline, as data_csv. It is processed in memory for the duration of the call and is not stored.',
+    '- Data reaches these tools inline, as data_csv. It is parsed in memory for the call and discarded when the call returns: the server keeps no rows and no CSV text, in memory or on disk.',
+    `- What a model_id refers to — the fitted model: points, networks, unit labels and group values, never the rows — stays in memory for ${Math.round(MODEL_TTL_MS / 60_000)} minutes after its last use, then is forgotten. ena_simplify refits and ena_export packs the data file, so they take data_csv again; ena_export with format="set" takes none.`,
     '- Before the first analysis, tell the user that the data leaves their machine and must be de-identified: no names, e-mail addresses or identifying free text. Ask them to confirm before sending it.',
     '- Results include unit labels (the values of the unit columns, often participant IDs) and group values. If those are identifying, tell the user before fitting so they can pseudonymize the data first.',
-    '- The guide may mention data_path, ena_profile, ena_tables, ena_lines or ena_export; those are for the locally installed server and are not available here.',
+    '- The guide may mention data_path, ena_profile, ena_tables or ena_lines; those are for the locally installed server and are not available here.',
+    '- ena_export returns the ENA Web Tool project ZIP inline (a base64 resource) when it gets data_csv again. If the client cannot save a file from a result, use format="set" and give the user the set file and the packing steps from the summary; their data file never has to come back here.',
     '',
     'Results come only from these tools — follow in every conversation:',
     '- Every ENA, ONA or TMA result shown to the user (accumulated networks, points, rotations, statistics, plots) must come from these tools. Do not compute any part of an ENA analysis yourself — in code, a notebook, R, Python or by hand — and do not draw ENA-style network plots of your own.',
@@ -3329,7 +3465,7 @@ const on = (schema, handler) => HANDLERS.push([schema, handler]);
 function buildServer() {
     const server = new Server(
         { name: 'ena', version: PKG.version },
-        { capabilities: { tools: {}, prompts: {} }, instructions: SERVER_INSTRUCTIONS }
+        { capabilities: { tools: {}, prompts: {} }, instructions: serverInstructions() }
     );
     for (const [schema, handler] of HANDLERS) server.setRequestHandler(schema, handler);
     return server;
@@ -3476,10 +3612,14 @@ on(CallToolRequestSchema, async (request) => {
         }
 
         // Extract viz fields before stringifying so they never appear in the text block.
-        const { _plot, ...cleanResult } = result;
+        const { _plot, _zip, ...cleanResult } = result;
 
         cleanResult.provenance = PROVENANCE;
         const content = [{ type: 'text', text: JSON.stringify(cleanResult, null, 2) }];
+        if (_zip) content.push({
+            type: 'resource',
+            resource: { uri: `ena://export/${encodeURIComponent(_zip.name)}`, mimeType: 'application/zip', blob: _zip.data.toString('base64') },
+        });
 
         if (_plot) {
             const slug = vizSlug(cleanResult, args) || name;
@@ -3543,6 +3683,7 @@ on(CallToolRequestSchema, async (request) => {
 
         return { content };
     } catch (err) {
+        if (process.env.ENA_MCP_DEBUG) process.stderr.write((err.stack ?? '') + '\n');
         return {
             content: [{ type: 'text', text: `Error: ${withholdDataValues(err.message, args)}\n\n${NO_SUBSTITUTE}` }],
             isError: true,
@@ -3550,10 +3691,43 @@ on(CallToolRequestSchema, async (request) => {
     }
 });
 
-// ── Start ─────────────────────────────────────────────────────────────────────
+// ── Web-standard entry (Workers and other fetch runtimes) ─────────────────────
+// Same stateless scheme as --http below, over Request/Response. A Worker
+// bundle imports this and never reaches the start block.
+
+export { buildServer };
+
+export async function handleWebRequest(request, { maxBody = HTTP_MAX_BODY } = {}) {
+    const url = new URL(request.url);
+    const json = (status, body) => Response.json(body, { status });
+    if (url.pathname === '/healthz') return json(200, { ok: true, server: PKG.name, version: PKG.version });
+    if (url.pathname !== HTTP_PATH) return json(404, { error: `MCP endpoint is ${HTTP_PATH}` });
+    let parsedBody;
+    if (request.method === 'POST') {
+        const tooLarge = () => json(413, { error: `request body too large (limit ${Math.round(maxBody / 1048576)} MB)` });
+        if (Number(request.headers.get('content-length')) > maxBody) return tooLarge();
+        const raw = await request.text();
+        if (raw.length > maxBody) return tooLarge();
+        try { parsedBody = JSON.parse(raw); }
+        catch { return json(400, { jsonrpc: '2.0', error: { code: -32700, message: 'Parse error' }, id: null }); }
+    }
+    const { WebStandardStreamableHTTPServerTransport } = await import('@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js');
+    const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    await buildServer().connect(transport);
+    return transport.handleRequest(request, { parsedBody });
+}
 
-if (!REMOTE) {
-    await buildServer().connect(new StdioServerTransport());
+// ── Start ─────────────────────────────────────────────────────────────────────
+// Skipped when embedded (a Worker sets globalThis.ENA_MCP_EMBEDDED before
+// importing this module and calls handleWebRequest itself).
+
+if (globalThis.ENA_MCP_EMBEDDED) {
+    // nothing to start
+} else if (!REMOTE) {
+    buildServer().connect(new StdioServerTransport()).catch((e) => {
+        process.stderr.write(`[ena-mcp] stdio: ${e.message}\n`);
+        process.exit(1);
+    });
 } else {
     // Streamable HTTP, stateless: every POST gets a fresh Server + transport
     // and is answered in full, so no session state lives in the process and
@@ -3602,4 +3776,5 @@ if (!REMOTE) {
     http.listen(HTTP_PORT, HTTP_HOST, () => {
         process.stderr.write(`[ena-mcp] ${PKG.name} ${PKG.version} serving MCP over HTTP at http://${HTTP_HOST}:${HTTP_PORT}${HTTP_PATH} (health: /healthz)\n`);
     });
+    setInterval(expireModels, 60_000).unref();   // idle models leave on time, not at the next request
 }