@crvouga/atlas 0.5.0 → 0.6.1

package/dist/server/src/dev.js

@@ -1,23 +1,24 @@
 /**
  * @module `atlas dev`
  *
- * Runs the same server as `atlas serve` on a port of its own, with the viewer's Vite dev server in front of it. Vite proxies
+ * Runs the same server as `atlas serve` on a port of its own, with the client's Vite dev server in front of it. Vite proxies
  * `/api` (server-sent events included) to the server and writes the same address book into the page, so the browser, the
- * uploaders and the viewer all use one host, exactly as in production, and a change to the viewer shows at once.
+ * uploaders and the client all use one host, exactly as in production, and a change to the client shows at once.
  */
 import path from 'node:path';
 import { openConfiguredBackends, serverOptionsOf } from './main.js';
 import { createAtlasServer } from './app.js';
 import { ConfigError, loadServerConfig, SERVER_USAGE } from './config.js';
 import { listen } from './host.js';
+import { fileServerSettings } from './settings.js';
 import { visualizerRoot } from './site.js';
 /** The text `atlas dev --help` prints. Also the source of the `atlas dev` section of `docs/reference/cli.md`. */
-export const DEV_USAGE = `atlas dev: the Atlas server and the viewer, for working on either
+export const DEV_USAGE = `atlas dev: the Atlas server and the client, for working on either
 
   atlas dev [--port 5180] [--host 127.0.0.1] [--data <dir>] [--store <url|id=url>]... [--config atlas.server.json]
 
-  Starts the server (API only, on a port of its own) and the viewer's dev server, which proxies /api to it, so the
-  browser talks to one host and a change to the viewer shows at once. In production \`atlas serve\` does both from
+  Starts the server (API only, on a port of its own) and the client's dev server, which proxies /api to it, so the
+  browser talks to one host and a change to the client shows at once. In production \`atlas serve\` does both from
   one process.
 `;
 /** `atlas dev`. */
@@ -30,16 +31,16 @@ export async function devMain(argv, io) {
     }
     const root = visualizerRoot();
     if (!root) {
-        io.out('atlas dev: the viewer is not installed alongside the server.\n');
+        io.out('atlas dev: the client is not installed alongside the server.\n');
         return 2;
     }
-    // --port is the one the browser uses (the viewer's); the API takes another that nobody needs to know.
+    // --port is the one the browser uses (the client's); the API takes another that nobody needs to know.
     const flagged = argv.findIndex(item => item === '--port');
     const publicPort = flagged >= 0 ? Number(argv[flagged + 1]) : Number(env.ATLAS_PORT ?? env.PORT ?? 5180);
     const forServer = argv.filter((_, i) => i !== flagged && i !== flagged + 1 || flagged < 0);
     let config;
     try {
-        // The API itself listens on a port of its own on this machine; what the user said about --host is for the viewer, the one door.
+        // The API itself listens on a port of its own on this machine; what the user said about --host is for the client, the one door.
         config = loadServerConfig([...forServer, '--port', '0'], { ...env, PORT: undefined, ATLAS_PORT: undefined }, cwd);
     }
     catch (error) {
@@ -50,10 +51,10 @@ export async function devMain(argv, io) {
         throw error;
     }
     const backends = openConfiguredBackends(config, env, cwd);
-    const api = createAtlasServer(serverOptionsOf(config, backends, line => io.out(`${JSON.stringify(line)}\n`)));
-    const running = await listen(api.fetch, { port: 0, host: '127.0.0.1', maxBodyBytes: config.limits.maxObjectMiB * 1024 * 1024 });
+    const api = createAtlasServer({ ...serverOptionsOf(config, backends, line => io.out(`${JSON.stringify(line)}\n`)), settings: fileServerSettings(config, forServer, env, cwd) });
+    const running = await listen(api.fetch, { port: 0, host: '127.0.0.1', maxBodyBytes: Math.max(config.limits.maxObjectMiB, config.limits.maxJsonMiB) * 1024 * 1024 });
     await api.ready;
-    // The viewer's config reads this to proxy /api, and to write the same page config a server would.
+    // The client's config reads this to proxy /api, and to write the same page config a server would.
     process.env.ATLAS_API_URL = running.url.replace('localhost', '127.0.0.1');
     process.env.INIT_CWD = cwd;
     const { createServer } = await import('vite');
@@ -61,9 +62,17 @@ export async function devMain(argv, io) {
         configFile: path.join(root, 'vite.config.ts'),
         configLoader: 'runner',
         root,
-        server: { port: publicPort, host: config.host, strictPort: false }
+        server: { port: publicPort, host: config.host, strictPort: true }
     });
-    await vite.listen();
+    try {
+        await vite.listen();
+    }
+    catch (error) {
+        api.close();
+        await vite.close();
+        await running.close(2_000);
+        throw error;
+    }
     vite.printUrls();
     io.out(`Data in ${path.relative(cwd, config.data) || config.data}. Publish with: ATLAS_STORE=${vite.resolvedUrls?.local[0] ?? `http://localhost:${publicPort}`} atlas report publish …\n`);
     await new Promise(resolve => {

package/dist/server/src/events.d.ts

@@ -2,15 +2,15 @@
  * @module Server-sent events
  *
  * What the server tells every connected viewer the moment it happens. A viewer that misses some (a dropped connection, a
- * laptop that slept) loses nothing: events say "something changed", the state is always fetched, and a viewer reads again
+ * laptop that slept) loses nothing: report events announce changes, run events carry bounded progress snapshots, and a viewer reads authoritative state again
  * when it reconnects. `EventHub` encodes each event once for all viewers, sends a named `ping` every heartbeat so proxies
  * keep the connection and a quiet server is told apart from a dead one, refuses past a maximum number of viewers (they poll
  * instead), and lets go of a viewer that has stopped reading rather than hold its backlog.
  *
  * @see docs/server.md#streaming
  */
-/** The events the server publishes: `hello` (sent first to a new viewer), `report` (layers arrived) and `atlas:change` (specs or runs changed). `ping` is the heartbeat, sent by the hub itself. */
-export type EventName = 'hello' | 'report' | 'atlas:change';
+/** The events the server publishes: `hello` (sent first to a new viewer), `report` (layers arrived) `atlas:change` (specs or runs changed), `run` (a bounded live lease snapshot), and `projects` (project discovery changed). `ping` is the heartbeat, sent by the hub itself. */
+export type EventName = 'hello' | 'report' | 'atlas:change' | 'run' | 'projects';
 /** The viewers connected to `/api/events` and how to reach them all. One hub per server. */
 export declare class EventHub {
     #private;

package/dist/server/src/events.js

@@ -2,7 +2,7 @@
  * @module Server-sent events
  *
  * What the server tells every connected viewer the moment it happens. A viewer that misses some (a dropped connection, a
- * laptop that slept) loses nothing: events say "something changed", the state is always fetched, and a viewer reads again
+ * laptop that slept) loses nothing: report events announce changes, run events carry bounded progress snapshots, and a viewer reads authoritative state again
  * when it reconnects. `EventHub` encodes each event once for all viewers, sends a named `ping` every heartbeat so proxies
  * keep the connection and a quiet server is told apart from a dead one, refuses past a maximum number of viewers (they poll
  * instead), and lets go of a viewer that has stopped reading rather than hold its backlog.

package/dist/server/src/index.d.ts

@@ -14,3 +14,5 @@ export { EventHub, type EventName } from './events.js';
 export { listen, type RunningServer } from './host.js';
 export { serveMain } from './main.js';
 export { classify, validateUpload, validKey, Refusal } from './validate.js';
+export { fileServerSettings, type ServerSettings, type SettingsSnapshot } from './settings.js';
+export { LiveRuns, LiveRunError } from './live-runs.js';

package/dist/server/src/index.js

@@ -14,3 +14,5 @@ export { EventHub } from './events.js';
 export { listen } from './host.js';
 export { serveMain } from './main.js';
 export { classify, validateUpload, validKey, Refusal } from './validate.js';
+export { fileServerSettings } from './settings.js';
+export { LiveRuns, LiveRunError } from './live-runs.js';

package/dist/server/src/live-runs.d.ts

@@ -0,0 +1,52 @@
+import type { z } from 'zod/v4';
+import { type LiveRun, type LiveRunStartSchema, type LiveRunUpdateSchema } from '../../schema/src/live-run.js';
+import type { ObjectStore } from '../../reports/src/object-store.js';
+import type { ReportLayer } from '../../reports/src/layer-types.js';
+type Start = z.output<typeof LiveRunStartSchema>;
+type Update = z.output<typeof LiveRunUpdateSchema>;
+/** A refused run update: 403 another publisher, 404 unknown run, 409 stale/terminal run, or 429 capacity. */
+export declare class LiveRunError extends Error {
+    readonly status: 403 | 404 | 409 | 429;
+    constructor(status: 403 | 404 | 409 | 429, message: string);
+}
+/**
+ * One server's live feed. Heartbeats never create result layers. Persisted summaries contain at most 20 recent
+ * checks and 10 active checks; completed results live in ordinary immutable layers. Leases expire by server time.
+ * @example
+ * const live = new LiveRuns({ store, timeoutMs: 30_000, stalledMs: 900_000, onChange: () => {}, onLayer: async () => {} });
+ */
+export declare class LiveRuns {
+    private readonly options;
+    private readonly held;
+    private readonly attempts;
+    private readonly queues;
+    /** Resolves after restoring summaries and interrupting leases left by a previous server process. */
+    readonly ready: Promise<void>;
+    private readonly now;
+    constructor(options: {
+        store: ObjectStore;
+        timeoutMs: number;
+        stalledMs: number;
+        now?: () => number;
+        onChange: (run: LiveRun) => void;
+        onLayer: (key: string, layer: ReportLayer) => Promise<void>;
+    });
+    private restore;
+    private save;
+    private locked;
+    private state;
+    private interrupt;
+    private expired;
+    private requireLive;
+    /** Read the most recent 50 summaries. Progress detail and counters are already bounded and cached. */
+    list(): Promise<LiveRun[]>;
+    /** Register one producer lease. Retrying an identical start is idempotent. */
+    start(input: Start, owner: string): Promise<LiveRun>;
+    /** Renew liveness by server receipt time, independently of whether a test made progress. */
+    heartbeat(id: string, owner: string): Promise<void>;
+    /** Apply one ordered progress batch and publish its completed checks before acknowledging it. */
+    update(id: string, input: Update, owner: string): Promise<LiveRun>;
+    /** Expire silent producers and optional progress stalls. Heartbeats cannot revive an expired run. */
+    sweep(): Promise<void>;
+}
+export {};

package/dist/server/src/live-runs.js

@@ -0,0 +1,229 @@
+/** @module Live run leases
+ * Tracks producer heartbeats independently of progress, publishes completed checks incrementally, and persists
+ * bounded run summaries. A server restart interrupts outstanding leases rather than inventing continued progress.
+ */
+import { createHash } from 'node:crypto';
+import { LiveRunSchema } from '../../schema/src/live-run.js';
+import { readUtf8, writeUtf8 } from '../../reports/src/object-io.js';
+import { publishChecks } from '../../reports/src/publish-checks.js';
+import { layerCatalogKey } from '../../reports/src/layer-store.js';
+const PREFIX = 'server/live/';
+const keyOf = (run) => `${PREFIX}${String(Number.MAX_SAFE_INTEGER - run.startedAtMs).padStart(16, '0')}-${run.id}.json`;
+/** A refused run update: 403 another publisher, 404 unknown run, 409 stale/terminal run, or 429 capacity. */
+export class LiveRunError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+/**
+ * One server's live feed. Heartbeats never create result layers. Persisted summaries contain at most 20 recent
+ * checks and 10 active checks; completed results live in ordinary immutable layers. Leases expire by server time.
+ * @example
+ * const live = new LiveRuns({ store, timeoutMs: 30_000, stalledMs: 900_000, onChange: () => {}, onLayer: async () => {} });
+ */
+export class LiveRuns {
+    options;
+    held = new Map();
+    attempts = new Map();
+    queues = new Map();
+    /** Resolves after restoring summaries and interrupting leases left by a previous server process. */
+    ready;
+    now;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.ready = this.restore();
+        // Requests await ready and surface failures; no unhandled rejection while a backend is unavailable.
+        void this.ready.catch(() => undefined);
+    }
+    async restore() {
+        const keys = (await this.options.store.listKeys(PREFIX)).slice(0, 200);
+        for (const key of keys) {
+            const text = await readUtf8(this.options.store, key);
+            if (text === null)
+                continue;
+            const stored = JSON.parse(text);
+            const run = LiveRunSchema.parse(stored.run);
+            const state = { run, owner: stored.owner, digest: stored.digest, states: new Map() };
+            this.held.set(run.id, state);
+            if (run.status === 'running')
+                await this.interrupt(state, 'The Atlas server restarted before the run completed.');
+        }
+    }
+    async save(state) {
+        await writeUtf8(this.options.store, keyOf(state.run), JSON.stringify({ run: state.run, owner: state.owner, digest: state.digest }), 'application/json');
+    }
+    locked(id, action) {
+        const next = (this.queues.get(id) ?? Promise.resolve()).catch(() => { }).then(action);
+        this.queues.set(id, next);
+        return next.finally(() => { if (this.queues.get(id) === next)
+            this.queues.delete(id); });
+    }
+    state(id, owner) {
+        const held = this.held.get(id);
+        if (!held)
+            throw new LiveRunError(404, 'Unknown run.');
+        if (held.owner !== owner)
+            throw new LiveRunError(403, 'This run belongs to another publisher.');
+        return held;
+    }
+    async interrupt(state, reason) {
+        const next = { ...state, states: new Map(), run: { ...state.run, status: 'interrupted', reason, finishedAtMs: this.now(), running: 0,
+                current: state.run.current.map(check => ({ ...check, status: 'not-run', detail: reason })) } };
+        await this.save(next);
+        this.held.set(next.run.id, next);
+        this.options.onChange(next.run);
+    }
+    expired(run) {
+        if (this.now() - run.lastHeartbeatAtMs >= this.options.timeoutMs)
+            return 'Producer heartbeat timed out. The run may have exited or lost its connection.';
+        if (this.options.stalledMs > 0 && this.now() - run.lastProgressAtMs >= this.options.stalledMs)
+            return 'No test progress arrived before the configured stall timeout.';
+        return undefined;
+    }
+    async requireLive(state) {
+        if (state.run.status !== 'running')
+            throw new LiveRunError(409, 'This run has ended.');
+        const reason = this.expired(state.run);
+        if (reason) {
+            await this.interrupt(state, reason);
+            throw new LiveRunError(409, reason);
+        }
+    }
+    /** Read the most recent 50 summaries. Progress detail and counters are already bounded and cached. */
+    async list() {
+        await this.ready;
+        return [...this.held.values()].map(state => state.run).sort((a, b) => b.startedAtMs - a.startedAtMs || a.id.localeCompare(b.id)).slice(0, 50);
+    }
+    /** Register one producer lease. Retrying an identical start is idempotent. */
+    async start(input, owner) {
+        await this.ready;
+        return this.locked(input.id, async () => {
+            const prior = this.held.get(input.id);
+            if (prior) {
+                const found = this.state(input.id, owner);
+                if (Object.entries(input).some(([key, value]) => found.run[key] !== value))
+                    throw new LiveRunError(409, 'A run id cannot be reused with another identity.');
+                return found.run;
+            }
+            if ([...this.held.values()].filter(state => state.run.status === 'running').length >= 100)
+                throw new LiveRunError(429, 'Too many live runs.');
+            const now = this.now();
+            const state = { owner, digest: '', states: new Map(), run: { ...input, status: 'running', sequence: 0, startedAtMs: now, lastHeartbeatAtMs: now, lastProgressAtMs: now, completed: 0, passed: 0, failed: 0, notRun: 0, running: 0, current: [], recent: [] } };
+            await this.save(state);
+            this.held.set(input.id, state);
+            // Retain bounded terminal history in memory; durable summaries remain in the configured backend.
+            if (this.held.size > 200) {
+                const old = [...this.held.values()].filter(value => value.run.status !== 'running').sort((a, b) => a.run.startedAtMs - b.run.startedAtMs)[0];
+                if (old)
+                    this.held.delete(old.run.id);
+            }
+            this.options.onChange(state.run);
+            return state.run;
+        });
+    }
+    /** Renew liveness by server receipt time, independently of whether a test made progress. */
+    async heartbeat(id, owner) {
+        await this.ready;
+        await this.locked(id, async () => {
+            const state = this.state(id, owner);
+            await this.requireLive(state);
+            const next = { ...state, run: { ...state.run, lastHeartbeatAtMs: this.now() } };
+            await this.save(next);
+            this.held.set(id, next);
+            this.options.onChange(next.run);
+        });
+    }
+    /** Apply one ordered progress batch and publish its completed checks before acknowledging it. */
+    async update(id, input, owner) {
+        await this.ready;
+        return this.locked(id, async () => {
+            const state = this.state(id, owner);
+            const digest = createHash('sha256').update(JSON.stringify(input)).digest('hex');
+            if (input.sequence === state.run.sequence && digest === state.digest)
+                return state.run;
+            await this.requireLive(state);
+            if (input.sequence !== state.run.sequence + 1)
+                throw new LiveRunError(409, 'This run ended or its progress sequence is stale.');
+            if (state.states.size + input.checks.filter(check => !state.states.has(check.id)).length > 100_000)
+                throw new LiveRunError(429, 'A live run may track at most 100000 check identities.');
+            const priorAttempt = this.attempts.get(id);
+            if (priorAttempt && (priorAttempt.sequence !== input.sequence || priorAttempt.digest !== digest))
+                throw new LiveRunError(409, 'Retry the pending sequence with identical content.');
+            const now = priorAttempt?.at ?? Math.max(this.now(), state.run.lastProgressAtMs + 1);
+            const states = new Map(state.states);
+            const run = { ...state.run, sequence: input.sequence, lastHeartbeatAtMs: now, ...(input.checks.length ? { lastProgressAtMs: now } : {}) };
+            const current = new Map(run.current.map(check => [check.id, check]));
+            for (const check of input.checks) {
+                const prior = states.get(check.id);
+                if (prior === 'running')
+                    run.running--;
+                else if (prior) {
+                    run.completed--;
+                    if (prior === 'passed')
+                        run.passed--;
+                    else if (prior === 'failed')
+                        run.failed--;
+                    else
+                        run.notRun--;
+                }
+                states.set(check.id, check.status);
+                if (check.status === 'running') {
+                    run.running++;
+                    current.set(check.id, check);
+                }
+                else {
+                    run.completed++;
+                    if (check.status === 'passed')
+                        run.passed++;
+                    else if (check.status === 'failed')
+                        run.failed++;
+                    else
+                        run.notRun++;
+                    current.delete(check.id);
+                }
+            }
+            run.current = [...current.values()].slice(-10);
+            run.recent = [...input.checks].reverse().concat(run.recent.filter(check => !input.checks.some(next => next.id === check.id))).slice(0, 20);
+            if (input.finish) {
+                if (input.finish === 'completed' && run.running)
+                    throw new LiveRunError(409, 'Finish running checks before completing the run.');
+                run.status = input.finish;
+                run.finishedAtMs = now;
+                run.reason = input.reason;
+                if (input.finish === 'interrupted') {
+                    run.running = 0;
+                    run.current = run.current.map(check => ({ ...check, status: 'not-run', detail: input.reason ?? 'Run interrupted.' }));
+                }
+                states.clear();
+            }
+            const finished = input.checks.filter(check => check.status !== 'running');
+            this.attempts.set(id, { sequence: input.sequence, digest, at: now });
+            if (finished.length) {
+                const layer = await publishChecks(this.options.store, { producer: state.run.producer, environment: state.run.environment, branch: state.run.branch, sha: state.run.sha, recordedAtMs: now,
+                    labels: { 'atlas.run': id }, checks: finished });
+                await this.options.onLayer(layerCatalogKey(layer.recordedAtMs, layer.id), layer);
+            }
+            const next = { ...state, states, run, digest };
+            await this.save(next);
+            this.held.set(id, next);
+            this.attempts.delete(id);
+            this.options.onChange(run);
+            return run;
+        });
+    }
+    /** Expire silent producers and optional progress stalls. Heartbeats cannot revive an expired run. */
+    async sweep() {
+        await this.ready;
+        await Promise.all([...this.held.keys()].map(id => this.locked(id, async () => {
+            const state = this.held.get(id);
+            if (state.run.status !== 'running')
+                return;
+            const reason = this.expired(state.run);
+            if (reason)
+                await this.interrupt(state, reason);
+        })));
+    }
+}

package/dist/server/src/llms.js

@@ -6,6 +6,7 @@
  * address, whether it needs a token), so what it says is true of the server that says it, and it points at the
  * machine-readable description (`/api/openapi.json`) rather than repeating it.
  */
+import { packageManagerTable } from '../../reports/src/package-managers.js';
 /** The guide for one server, Markdown. Stable in structure: an agent may read it by its headings. */
 export function llmsTxt(context) {
     const { url } = context;
@@ -28,27 +29,35 @@ ${context.open
 
 ## Integrate a project (run in the project's repository)
 
+Install \`@crvouga/atlas\` with the project's existing package manager first. The commands below use Bun;
+substitute the executor for your package manager. Node also runs the CLI; Bun is optional. Read the installed
+\`docs/agents.md\` for the supported runtime versions and full integration playbook.
+
+${packageManagerTable()}
+
 \`\`\`sh
+bun add -d @crvouga/atlas
 export ATLAS_STORE=${url}${context.open ? '' : '\nexport ATLAS_TOKEN=<a publish token>'}
-bunx @crvouga/atlas init --server ${url}          # detects test runners and specs, prints a plan (add --json for a machine-readable one)
-bunx @crvouga/atlas init --server ${url} --write  # writes the CI workflow and the AGENTS.md section the plan names
-bunx @crvouga/atlas report doctor                 # proves the server can be written to and read
+export ATLAS_PROJECT=checkout-service          # choose the same stable slug locally and in CI
+bunx atlas init --server ${url}                # detects test runners and specs, prints a plan (add --json for a machine-readable one)
+bunx atlas init --server ${url} --write        # writes the CI workflow and the AGENTS.md section the plan names
+bunx atlas report doctor                       # proves the server can be written to and read
 \`\`\`
 
 After each suite, send its results (a JUnit or CTRF file, or JSON lines as checks finish):
 
 \`\`\`sh
-bunx @crvouga/atlas report publish --producer <suite> --junit out.xml --specs ./specs --environment <env>
-my-suite --json | bunx @crvouga/atlas report stream --producer <suite> --environment <env>
+bunx atlas report publish --producer <suite> --junit out.xml --specs ./specs --environment <env>
+my-suite --json | bunx atlas report stream --producer <suite> --environment <env>
 \`\`\`
 
-Or with no tooling at all: \`POST ${url}/api/checks\` with \`{"producer":"smoke","checks":[{"id":"login","title":"can log in","status":"passed"}]}\`.
+Or with no tooling at all: \`POST ${url}/api/checks?project=<slug>\` with \`{"producer":"smoke","checks":[{"id":"login","title":"can log in","status":"passed"}]}\`.
 
 ## Ask whether it passes
 
 \`\`\`sh
-bunx @crvouga/atlas report status --format json --branch main --ignore-modified   # exit 0 pass, 1 does not, 2 wrong command
-curl ${context.open ? '' : '-H "authorization: Bearer $ATLAS_TOKEN" '}${url}/api/status                      # the same verdict; header X-Atlas-Ok: true|false
+bunx atlas report status --format json --branch main --ignore-modified   # exit 0 pass, 1 does not, 2 wrong command
+curl ${context.open ? '' : '-H "authorization: Bearer $ATLAS_TOKEN" '}"${url}/api/status?project=$ATLAS_PROJECT"    # the same verdict; header X-Atlas-Ok: true|false
 \`\`\`
 
 ## Rules worth knowing

package/dist/server/src/main.d.ts

@@ -2,7 +2,7 @@
  * @module `atlas serve`
  *
  * Starts the Atlas server from its configuration: opens every backend (creating the data folder), proves the upload
- * backend can be written to before listening, finds or builds the viewer, listens at once (so a liveness probe finds the
+ * backend can be written to before listening, finds or builds the client, listens at once (so a liveness probe finds the
  * process while a large backend is still being read), and stops cleanly on SIGTERM or SIGINT. `serverOptionsOf` is shared
  * with `atlas dev`, so the two run the same server.
  *

package/dist/server/src/main.js

@@ -2,7 +2,7 @@
  * @module `atlas serve`
  *
  * Starts the Atlas server from its configuration: opens every backend (creating the data folder), proves the upload
- * backend can be written to before listening, finds or builds the viewer, listens at once (so a liveness probe finds the
+ * backend can be written to before listening, finds or builds the client, listens at once (so a liveness probe finds the
  * process while a large backend is still being read), and stops cleanly on SIGTERM or SIGINT. `serverOptionsOf` is shared
  * with `atlas dev`, so the two run the same server.
  *
@@ -14,6 +14,7 @@ import { openStore } from '../../reports/src/store-url.js';
 import { createAtlasServer } from './app.js';
 import { ConfigError, loadServerConfig, SERVER_USAGE } from './config.js';
 import { listen } from './host.js';
+import { fileServerSettings } from './settings.js';
 import { findSite } from './site.js';
 /** Open every backend of a configuration. The data folder is made if it is not there. */
 export function openConfiguredBackends(config, env, cwd) {
@@ -45,9 +46,10 @@ export function serverOptionsOf(config, backends, log) {
         ? (layer) => (!branches?.length || (layer.branch !== null && branches.includes(layer.branch))) && (!config.include.ignoreModified || layer.freshness === undefined)
         : undefined;
     return {
-        backends, write: config.writeId, tokens: config.tokens, anonymousRead: config.anonymousRead,
+        backends, write: config.writeId,
+        ...(/^https?:\/\//.test(config.backends.find(backend => backend.id === config.writeId).url) ? { liveStore: backends[0].store } : {}), tokens: config.tokens, anonymousRead: config.anonymousRead,
         ...(config.outlineBranch ? { outlineBranch: config.outlineBranch } : {}), ...(include ? { include } : {}),
-        refreshMs: config.refreshSeconds * 1000, limits: config.limits, heartbeatMs: config.heartbeatSeconds * 1000,
+        runTimeoutMs: config.runTimeoutSeconds * 1000, runStallMs: config.runStallSeconds * 1000, refreshMs: config.refreshSeconds * 1000, limits: config.limits, heartbeatMs: config.heartbeatSeconds * 1000,
         ...(config.log && log ? { log } : {})
     };
 }
@@ -80,8 +82,8 @@ export async function serveMain(argv, io) {
     }
     const site = await findSite(config.site, cwd, io.out);
     if (!site)
-        io.out('No viewer to serve: build one with `atlas-visualizer build --no-data --out atlas-site`. The API is served meanwhile.\n');
-    const server = createAtlasServer({ ...serverOptionsOf(config, backends, line => io.out(`${JSON.stringify(line)}\n`)), ...(site ? { site } : {}) });
+        io.out('No Atlas client to serve: build one with `atlas client build --no-data --out atlas-site`. The API is served meanwhile.\n');
+    const server = createAtlasServer({ settings: fileServerSettings(config, argv, env, cwd), ...serverOptionsOf(config, backends, line => io.out(`${JSON.stringify(line)}\n`)), ...(site ? { site } : {}) });
     // Listen at once: the first pass over a large backend can take a while, and a liveness probe must find the
     // process meanwhile. /readyz is 503 until there is a report to show.
     const running = await listen(server.fetch, { port: config.port, host: config.host, maxBodyBytes: Math.max(config.limits.maxObjectMiB, config.limits.maxJsonMiB) * 1024 * 1024 });

package/dist/server/src/openapi.d.ts

@@ -1,5 +1,5 @@
 /** The version of the API described, `major.minor.patch`: the minor grows when an operation or field is added, the major never within `/api`. */
-export declare const API_VERSION = "1.0.0";
+export declare const API_VERSION = "1.3.0";
 /** Who may call an operation: `none` (anyone), or the least role that may (`read` < `publish` < `admin`). */
 export type Role = 'none' | 'read' | 'publish' | 'admin';
 type JsonSchema = Record<string, unknown>;
@@ -42,10 +42,7 @@ export type Operation = {
     readonly body?: Body;
     readonly responses: Readonly<Record<string, Response>>;
 };
-/**
- * Every operation of the API. The order is the order of the document. The descriptions are the documentation an
- * agent reads, so they say what to send, what comes back, and what to do when it does not work.
- */
+/** Every node operation and the same stable report protocol inside each project namespace. */
 export declare const OPERATIONS: readonly Operation[];
 /**
  * Routes the server registers that are not operations of this API, each with the reason. The coverage test skips