@crvouga/atlas 0.5.0 → 0.6.0

package/dist/server/src/store-api.js

@@ -23,16 +23,21 @@ export async function readLimited(request, limit) {
     const reader = request.body.getReader();
     const chunks = [];
     let size = 0;
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        size += value.byteLength;
-        if (size > limit) {
-            await reader.cancel();
-            throw new Refusal(413, `The body is over the limit of ${limit} bytes`);
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > limit) {
+                await reader.cancel();
+                throw new Refusal(413, `The body is over the limit of ${limit} bytes`);
+            }
+            chunks.push(value);
         }
-        chunks.push(value);
+    }
+    finally {
+        reader.releaseLock();
     }
     const out = new Uint8Array(size);
     let at = 0;
@@ -69,6 +74,20 @@ export function storeApi(options) {
     const { store, auth } = options;
     // A layer's manifest is validated when it arrives and its catalog entry follows: what was read the first time serves the second.
     const recent = new Map();
+    // Serialize only competing writes to the same key. Other uploads retain their concurrency.
+    const writing = new Map();
+    async function exclusive(key, action) {
+        const previous = writing.get(key) ?? Promise.resolve();
+        const next = previous.catch(() => undefined).then(action);
+        writing.set(key, next);
+        try {
+            return await next;
+        }
+        finally {
+            if (writing.get(key) === next)
+                writing.delete(key);
+        }
+    }
     const refuse = (c, status, message) => c.json({ error: message }, status);
     app.get('/', async (c) => {
         const verdict = auth.check(c.req.raw, 'read');
@@ -123,19 +142,21 @@ export function storeApi(options) {
             return refuse(c, 422, 'Not a key Atlas holds');
         try {
             const bytes = await readLimited(c.req.raw, options.maxObjectBytes);
-            const kind = await validateUpload(name, bytes, store, layer => { recent.set(layer.id, layer); if (recent.size > 8)
-                recent.delete(recent.keys().next().value); });
-            // A blob's name is the digest of what is in it, which was just checked: one that is there is this one, however it was compressed.
-            const present = kind === 'blob' && (await store.head(name)) ? 'same' : await sameBytes(store, name, bytes);
-            // Scratch objects may be overwritten (an object store's contract says writing a key twice is fine); layers may not.
-            if (present === 'different' && kind !== 'scratch')
-                throw new Refusal(409, `${name} already exists with other content. Layers are immutable: publish a new one.`);
-            if (present !== 'same')
-                await store.put(name, bytes, c.req.header('content-type') ?? 'application/octet-stream');
-            // Catalog entries make a layer, spec set or run visible, so everyone is told only once they are in.
-            if (present === 'absent' || isCatalog(kind))
-                await options.onStored(name, kind, kind === 'layer-catalog' ? recent.get(classify(name)?.id ?? '') : undefined);
-            return c.json({ ok: true, key: name, kind, created: present === 'absent' }, present === 'absent' ? 201 : 200);
+            return await exclusive(name, async () => {
+                const kind = await validateUpload(name, bytes, store, layer => { recent.set(layer.id, layer); if (recent.size > 8)
+                    recent.delete(recent.keys().next().value); });
+                // A blob's name is the digest of what is in it, which was just checked: one that is there is this one, however it was compressed.
+                const present = kind === 'blob' && (await store.head(name)) ? 'same' : await sameBytes(store, name, bytes);
+                // Scratch objects may be overwritten (an object store's contract says writing a key twice is fine); layers may not.
+                if (present === 'different' && kind !== 'scratch')
+                    throw new Refusal(409, `${name} already exists with other content. Layers are immutable: publish a new one.`);
+                if (present !== 'same')
+                    await store.put(name, bytes, c.req.header('content-type') ?? 'application/octet-stream');
+                // Catalog entries make a layer, spec set or run visible, so everyone is told only once they are in.
+                if (present === 'absent' || isCatalog(kind))
+                    await options.onStored(name, kind, kind === 'layer-catalog' ? recent.get(classify(name)?.id ?? '') : undefined);
+                return c.json({ ok: true, key: name, kind, created: present === 'absent' }, present === 'absent' ? 201 : 200);
+            });
         }
         catch (error) {
             if (error instanceof Refusal)

package/docs/deploying.md

@@ -68,7 +68,7 @@ so run `atlas report doctor` against yours before relying on it.
    ```sh
    atlas report policy --store s3://my-bucket/atlas/my-project --role publisher   # CI and developers
    atlas report policy --store s3://my-bucket/atlas/my-project --role reader      # a server that only reads it, and the gate
-   # the server that uploads into it needs --role both
+   # the server that uploads into it needs --role both (also grants server/live/* for live leases)
    ```
 
    A publisher may write and read `layers/*` and list the folder. A reader may read `layers/*` and list.
@@ -177,7 +177,7 @@ Everything is immutable and addressed by its content, so each publish is safe to
 in parallel. A set of specs is named by the files and the commit, so publishing the same commit from ten
 nodes writes it once.
 
-For statecharts, publish each run as a layer and upload it for the viewer:
+For statecharts, publish each run as a layer and upload it for the client:
 
 ```sh
 bunx atlas run --config atlas.config.ts --shard 1/2
@@ -185,7 +185,7 @@ bunx atlas report publish --producer statecharts --environment desktop-web \
   --manifest atlas-runs/<run>/manifest.json --specs ./specs --upload-run
 ```
 
-A run is uploaded only when its privacy scan passed: the same rule the static viewer applies.
+A run is uploaded only when its privacy scan passed: the same rule the static client applies.
 
 ## 4. The server
 
@@ -193,7 +193,7 @@ A run is uploaded only when its privacy scan passed: the same rule the static vi
 atlas serve                    # ATLAS_STORE says where; listens on :8080
 ```
 
-It serves the viewer, the report and the project's specs and runs from all configured backends. It also
+It serves the client, the report and the project's specs and runs from all configured backends. It also
 accepts uploads and announces new results on its event stream. Uploads go to `--data` by default;
 use a named `--store project=s3://… --write project` to put uploads in a shared bucket, with publisher permissions.
 
@@ -204,7 +204,7 @@ use a named `--store project=s3://… --write project` to put uploads in a share
 | `--write <id>` | `ATLAS_WRITE` | Backend that accepts uploads. Default `data`. |
 | `--port <n>` | `ATLAS_PORT` or `PORT` | Default 8080. `0` picks a free one. |
 | `--host <h>` | `ATLAS_HOST` or `HOST` | Default `127.0.0.1`. Listening beyond this machine requires tokens or `--insecure`. |
-| `--site <dir>` | `ATLAS_SITE` | The built viewer. Default: `./atlas-site`, else built once into `~/.cache/atlas/site`. |
+| `--site <dir>` | `ATLAS_SITE` | The built client. Default: `./atlas-site`, else built once into `~/.cache/atlas/site`. |
 | `--outline-branch <b>` | `ATLAS_OUTLINE_BRANCH` | Which branch's specs the report is laid over. Default `main`, then `master`, then the newest. |
 | `--refresh <seconds>` | `ATLAS_REFRESH_SECONDS` | How often the bucket is looked at for new layers. Default 10. |
 | `--branch <name>` (repeatable) | `ATLAS_ONLY_BRANCH` | Only layers recorded on these branches take part. |
@@ -214,7 +214,7 @@ use a named `--store project=s3://… --write project` to put uploads in a share
 ### Run it
 
 **Docker.** [`examples/deploy/Dockerfile`](https://github.com/crvouga/atlas/blob/main/examples/deploy/Dockerfile)
-installs Atlas, builds the viewer once (it is the same for every project: the server tells the page where its
+installs Atlas, builds the client once (it is the same for every project: the server tells the page where its
 data is) and starts the server, keeping results on the volume at `/data`:
 
 ```sh
@@ -223,7 +223,7 @@ docker run -p 8080:8080 -v atlas-data:/data -e ATLAS_TOKEN=$(openssl rand -hex 2
 ```
 
 For a bucket as the system of record add `-e ATLAS_STORE=project=s3://my-bucket/atlas/my-project -e ATLAS_WRITE=project -e AWS_REGION=us-east-1`.
-On ECS, EKS or EC2, attach a role with the **publisher** and **reader** policies to the task, service account or
+On ECS, EKS or EC2, attach the combined **both** policy (including `server/live/*` for producer leases) to the task, service account or
 instance and set no keys.
 
 **Try it on one machine.** [`examples/deploy/compose.yaml`](https://github.com/crvouga/atlas/blob/main/examples/deploy/compose.yaml)
@@ -234,7 +234,7 @@ Publish to `http://localhost:8080` from your project and open it.
 one copy (the server is a singleton for the project), results in the bucket, readiness on `/readyz`, an IRSA
 service account.
 
-**Without a container.** `bun add -d @crvouga/atlas`, then `bunx atlas-visualizer build --no-data --out
+**Without a container.** `bun add -d @crvouga/atlas`, then `bunx atlas client build --no-data --out
 atlas-site` and `bunx atlas serve`. It runs on Bun and on Node 22.18 or later. Everything it can be told is in
 [the Atlas server](server.md#configuration).
 
@@ -249,12 +249,12 @@ layer too. Pass `--insecure` only when that proxy handles sign-in.
 
 | Path | |
 | --- | --- |
-| `/` | The viewer. Its page carries the server's address book, so one build serves every project. |
+| `/` | The client. Its page carries the server's address book, so one build serves every project. |
 | `/api/reports/evidence/effective` | The whole report in one request: only the layers that win a check, each with only the rows that win. ETag, gzip. |
 | `/api/reports/evidence`, `/evidence/rows/<backend>/<id>`, `/outline`, `/outline/spec?path=` | History, one layer's checks, the specs. |
 | `/api/reports/evidence/detail/<backend>/<id>?check=<id>&kind=<kind>` | Everything one result carries: its timeline, annotations, retries, attachments and extensions, and the run's own. Without `check`, only the run's. |
 | `/api/reports/layers/<id>/blobs/<key>` | One file a layer carries (screenshot, video, trace…), served as untrusted bytes with range support, cached for good. |
-| `/api/data/specs/…`, `/api/data/runs/…`, `/api/data/sources.json` | The specs and runs, laid out the way the viewer reads a static host. |
+| `/api/data/specs/…`, `/api/data/runs/…`, `/api/data/sources.json` | The specs and runs, laid out the way the client reads a static host. |
 | `/api/checks` | Upload a layer of checks with `POST`. |
 | `/api/events` | Live report updates over server-sent events. |
 | `/healthz` | The process is up. |
@@ -277,7 +277,7 @@ Narrow it by choice, per consumer, never by moving data:
 | A pull request's gate that inherits what it did not re-run from `main` | `--branch "$PR_BRANCH" --branch main --ignore-modified` |
 | A business dashboard of what is committed | `atlas serve --ignore-modified` |
 | Everything, as the team lives it | nothing (the default) |
-| One person's view of what leaving a source out changes | **Sources** in the viewer: leave out a branch, environment, version or layer |
+| One person's view of what leaving a source out changes | **Sources** in the client: leave out a branch, environment, version or layer |
 
 ## 6. Operating it
 
@@ -287,12 +287,12 @@ Narrow it by choice, per consumer, never by moving data:
   they never need to move together.
 - **Logs.** One JSON line per request to stdout. `/healthz` and `/readyz` are not logged. At start it
   prints what it reads and any store it cannot reach.
-- **A store goes down.** The server keeps serving what it has, names the store in the viewer's notices and
+- **A store goes down.** The server keeps serving what it has, names the store in the client's notices and
   in `/readyz`, and recovers by itself. The gate fails closed: unknown is not a pass.
 - **A layer cannot be read** (corrupt, or written by a newer Atlas): a notice names it. It is tried again
   every five minutes.
-- **Scaling.** One server per project is the design, and it is enough: it takes in an upload in milliseconds and a
-  report of 100,000 checks costs a viewer kilobytes per change ([performance](server.md#performance)). Memory
+- **Scaling.** One Atlas node supports multiple project namespaces with independently loaded report indexes. It takes in an upload in milliseconds and a
+  report of 100,000 checks costs a client kilobytes per change ([performance](server.md#performance)). Memory
   grows with the number of distinct checks, plus about a hundred bytes for each layer ever seen (to know it has
   read it). More than one server on a backend works and shows the same report, but each hears of uploads to
   another only at its next refresh.
@@ -318,13 +318,13 @@ latency per request, which the server hides by reading 64 at a time):
 | Publish a layer of plain checks | One `HEAD` and two small `PUT`s. Two thousand layers published in under two seconds from one process, in parallel. |
 | Server start | About 0.2 ms of CPU per layer, plus S3 latency ÷ 64 per layer: 2,000 layers in well under a second on a fast store, a few seconds on S3. Each layer is read once, ever. |
 | Refresh with nothing new | One `LIST` request for the newest page of the catalog, whatever the history. |
-| The report, to a viewer | One request. 12,000 checks from 2,000 layers is 108 KB gzipped, built once per change. |
-| The viewer asking again | `304 Not Modified` in under a millisecond. While the live stream is open it asks only when told, and then for only what changed. |
-| The viewer in a browser | One request for the report, plus the spec index, outline and run index and the specs it opens. None per layer, whatever the history (measured in Chromium against a server reading S3). |
+| The report, to a client | One request. 12,000 checks from 2,000 layers is 108 KB gzipped, built once per change. |
+| The client asking again | `304 Not Modified` in under a millisecond. While the live stream is open it asks only when told, and then for only what changed. |
+| The client in a browser | One request for the report, plus the spec index, outline and run index and the specs it opens. None per layer, whatever the history (measured in Chromium against a server reading S3). |
 
 How: each layer is folded into the winning result of every check once and dropped unless it still holds a
 winner, so work and memory follow the number of checks. Because the winner rule is a total order, folding in
-any order is exact; a test proves the incremental report equals recomputing from every layer. The viewer
+any order is exact; a test proves the incremental report equals recomputing from every layer. The client
 reads that compact report in one request and only falls back to reading every layer when you ask it to
 leave a source out (which needs the history).
 
@@ -341,5 +341,5 @@ leave a source out (which needs the history).
 | The server says `listening … no backend can be read yet` | The bucket is unreachable from the server. It retries; `/readyz` stays 503 until it can read. |
 | A new layer does not show | Uploaded through the server it is there at once: check the token (`401`/`403` say so). Written straight to a bucket, wait one refresh interval (10 s). Check `atlas report status --store <url>` sees it. |
 | Everything is red because of one laptop | By design the newest result wins. Gate on `--ignore-modified` and a branch ([above](#5-choosing-what-takes-part)). |
-| Specs are empty in the viewer | Nothing published with `--specs` yet, or only from a branch other than `main`: set `--outline-branch`. |
+| Specs are empty in the client | Nothing published with `--specs` yet, or only from a branch other than `main`: set `--outline-branch`. |
 | `Run … is not shared: its privacy scan did not pass` | `--upload-run` refuses runs whose scan found real data. Fix what it found and run again. |

package/docs/dogfooding.md

@@ -51,7 +51,7 @@ and nothing runs just because the package is installed.
 | `@crvouga/atlas/reports/<module>` | Publishing, storing, combining, gating and serving test evidence for specs of any kind. |
 
 It also installs two commands: `atlas` (report, lint, plan, run, merge, export) and
-`atlas-visualizer` (browse specs, runs and reports).
+`atlas client` (browse specs, runs and reports).
 
 `playwright` and `detox` are optional peers: install the one your driver uses, as above. The
 documentation ships in the package, matching the version you installed: the README of each part at
@@ -151,7 +151,7 @@ Do this once per project. Check first that the package is on npm:
    | `@crvouga/atlas-schema` | `@crvouga/atlas/schema` |
    | `@crvouga/atlas-schema/schemas/<file>` | `@crvouga/atlas/schemas/<file>` |
    | `@crvouga/atlas-reports/<module>` | `@crvouga/atlas/reports/<module>` |
-   | `@crvouga/atlas-visualizer` (the `atlas-visualizer` command) | installed with `@crvouga/atlas` |
+   | `@crvouga/atlas client` (the `atlas client` command) | installed with `@crvouga/atlas` |
 
    `@crvouga/atlas`, `@crvouga/atlas/spec` and `@crvouga/atlas/signals` are unchanged. One pass
    over a project's sources does the rest:

package/docs/extending.md

@@ -31,7 +31,7 @@ carry any of these. Every one is optional.
 | `attempts[]` | Every try, when the check was retried. |
 | `tags[]` | Free labels to filter by: `smoke`, `payments`. |
 | `labels{}` | Facts about the result that are not its identity: `owner`, `severity`, `browser`, `build`. |
-| `links[]` | Where to read more: the CI run, the issue, the trace viewer. |
+| `links[]` | Where to read more: the CI run, the issue, the trace client. |
 | `extensions{}` | Structured data of your own or a tool's, under a name you own. |
 | `measurements[]` | Numbers, with units and an allowance (already part of the contract). |
 
@@ -224,7 +224,7 @@ Annotation `type`: `note`, `warning`, `deprecation`, `issue`, `accessibility`, `
 | Something that should be shown well | Ask for a renderer (below). |
 | A field every tool should have | Open an issue. It is added as an optional field, and the rules above guarantee nothing breaks. |
 
-**A renderer** is one entry in the viewer's list (`artifactRenderers` in
+**A renderer** is one entry in the client's list (`artifactRenderers` in
 `packages/visualizer/src/evidence/artifacts.tsx`): how to show an attachment of a media type. The first one that
 matches wins:
 
@@ -236,7 +236,7 @@ registerArtifactRenderer({
 });
 ```
 
-The viewer is part of Atlas, so a renderer for a new media type is a contribution to Atlas: file an issue
+The client is part of Atlas, so a renderer for a new media type is a contribution to Atlas: file an issue
 ([reporting issues](reporting-issues.md)) with a sample file. Until it lands, the attachment is still stored,
 listed with its name, role, type and size, and offered for download, and everything else about the result is
 unaffected.

package/docs/integrating.md

@@ -28,7 +28,7 @@ integrate. To run it for a whole team, with a bucket and one node everyone looks
 ```
  node 1: suite A, ios      ──▶ layer ─┐
  node 2: suite A, android  ──▶ layer ─┤        ┌──▶ atlas report status   (gate: exit 1 on failure)
- node 3: suite B, shard 1  ──▶ layer ─┼──▶ backends ──▶ combine ──┼──▶ the viewer          (browse it)
+ node 3: suite B, shard 1  ──▶ layer ─┼──▶ backends ──▶ combine ──┼──▶ the client          (browse it)
  node 4: suite B, shard 2  ──▶ layer ─┤        └──▶ your own code          (combineBackends)
  a laptop, one scenario    ──▶ layer ─┘
 ```
@@ -394,7 +394,7 @@ unknown is not a pass.
 
 ## 6. Browse it
 
-The visualizer lays your stores over your specs directory. Add a module to your project:
+The Atlas client lays your stores over your specs directory. Add a module to your project:
 
 ```ts
 // atlas.reports.ts
@@ -404,14 +404,14 @@ export const reportsDevFetch = reportsHost({ specs: './specs', stores: ['./atlas
 ```
 
 ```sh
-ATLAS_REPORTS_MODULE="$(pwd)/atlas.reports.ts" bunx atlas-visualizer dev --specs ./specs
+ATLAS_REPORTS_MODULE="$(pwd)/atlas.reports.ts" bunx atlas client dev --specs ./specs
 ```
 
 `reportsHost(options)` returns `(request: Request, repoRoot: string) => Promise<Response>`, the
-function the viewer calls for every `/api/reports/…` request. `specs` and directory `stores` resolve
-against `repoRoot`, which the viewer sets to where you ran the command (`INIT_CWD`), not against the
+function the client calls for every `/api/reports/…` request. `specs` and directory `stores` resolve
+against `repoRoot`, which the client sets to where you ran the command (`INIT_CWD`), not against the
 module. A wrong path comes back as a JSON error that names it. A `stores` entry that is not a string is
-a backend of your own: `{ id, label?, store }`. You can call it yourself to look at what the viewer
+a backend of your own: `{ id, label?, store }`. You can call it yourself to look at what the client
 sees:
 
 ```ts
@@ -424,11 +424,11 @@ const page = await (await reportsDevFetch(new Request('http://x/api/reports/evid
 
 | Route (after `/api/reports`) | Returns |
 | --- | --- |
-| `/evidence?cursor=` | A page of layer headers, the backends and any notices. The viewer combines them with the specs. |
+| `/evidence?cursor=` | A page of layer headers, the backends and any notices. The client combines them with the specs. |
 | `/evidence/rows/:backend/:id` | One layer's checks. |
 | `/outline`, `/outline/spec?path=` | The specs directory as an outline, and one spec's text. |
 
-The combined result of each spec is computed in the viewer. To get it without a browser, use
+The combined result of each spec is computed in the client. To get it without a browser, use
 `atlas report status --format json`: its `specs` array has each spec's counts per environment.
 
 Specs are the files of the specs directory (`.feature` as Gherkin, `.qnt` as Quint, `.dmn`, `.als`,
@@ -469,7 +469,7 @@ An integration is complete when each of these holds. Run them and keep the outpu
 | `X is unavailable` | A backend is down. The rest were combined; fix it or leave it out. |
 | `check id "…" appears twice` | Your suite emits two checks with one name. Make the names unique. Importers number repeats as `#2`. |
 | `Potentially outdated: spec changed` | The spec changed since the layer was recorded. Advisory: the recorded outcome still counts. Re-run to refresh. |
-| Viewer shows `No report store is configured` | `ATLAS_REPORTS_MODULE` is unset, or `stores` is empty. |
+| Client shows `No report store is configured` | `ATLAS_REPORTS_MODULE` is unset, or `stores` is empty. |
 
 ## Rules
 

package/docs/reference/cli.md

@@ -16,8 +16,9 @@ atlas — executable statecharts
                [--no-retry] [--output <dir>]
   atlas merge  [--config atlas.config.ts] [--output <dir>] <run-dir> <run-dir>...
   atlas export --specs <dir> --format scxml|mermaid|markdown|json [--out <file>]
-  atlas serve  [--data <dir>] [--port 8080] [--store <url>]...   the Atlas server: results in, the live report out
-  atlas dev    [--port 5180]                                     the server and the viewer's dev server, on one host
+  atlas server [--data <dir>] [--port 8080] [--store <url>]...   one Atlas node: API, projects and client
+  atlas client build [--no-data] [--out <dir>]                    build the project-agnostic Atlas client
+  atlas dev    [--port 5180]                                     develop the Atlas server and client on one host
   atlas init   [--server <url>] [--write]                         integrate this project: detect its suites, print the plan (atlas init --help)
   atlas report publish|stream|status|merge|doctor|policy …       layered evidence for any kind of spec (atlas report --help)
 
@@ -57,7 +58,7 @@ atlas serve: the Atlas server
               [--outline-branch <b>] [--branch <name>]... [--ignore-modified] [--refresh <seconds>]
               [--anonymous-read] [--insecure] [--no-log]
 
-  One process serves the viewer and the API. Test results are uploaded to it from anywhere (laptops, CI) and it
+  One process serves the client and the API. Test results are uploaded to it from anywhere (laptops, CI) and it
   shows everyone the combined report, live. It keeps its data in --data (default ./atlas-data) and can read more
   backends (--store): S3, other servers, folders. Uploads go to the data folder unless --write names another.
 
@@ -68,12 +69,12 @@ atlas serve: the Atlas server
 ## atlas dev
 
 ```text
-atlas dev: the Atlas server and the viewer, for working on either
+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.
 ```
 
@@ -101,7 +102,8 @@ atlas report — layered evidence for any kind of spec
   atlas report policy  --store s3://bucket/prefix [--role publisher|reader|both]
 
   A store is a directory or s3://bucket/prefix (add ?region=…&endpoint=… for R2, MinIO and the
-  rest). When no --store is given, ATLAS_STORE is used. Keys never go in the URL: set
+  rest). Select a project on an Atlas node with --project <slug> or ATLAS_PROJECT. This scopes specs, reports and recordings together.
+  When no --store is given, ATLAS_STORE is used. Keys never go in the URL: set
   AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, or sign in with `aws sso login`, or use a role.
 
   publish   Write one immutable layer: the checks of one producer, on one environment. Safe to repeat.

package/docs/reference/core.md

@@ -49,6 +49,8 @@ See docs/statecharts.md
 export type AtlasConfig<C = unknown> = {
   /** The directory holding the charts (`*.scxml`, `*.machine.{json,yaml}`) and `journeys.yaml`. */
   specs: string;
+  /** Live reporting endpoint. Defaults to ATLAS_SERVER_URL when set; false disables streaming. */
+  reporting?: LiveReporterOptions | false;
   /** The chart to run; the root chart when omitted. */
   chart?: string;
   /** Where generated paths start (an XState state value); the initial state when omitted. */
@@ -149,6 +151,8 @@ not thrown.
 export type RunCommandOptions = PrepareOptions & {
   /** `fast` when omitted. */
   mode?: RunMode;
+  /** Override live reporting. Defaults to config.reporting or ATLAS_SERVER_URL. */
+  reporting?: LiveReporterOptions | false;
   /** Only these paths, by id. */
   paths?: string[];
   /** Only paths that start from these seeds ("start" for paths that `setup` starts). */
@@ -1071,6 +1075,8 @@ export type RunOptions<C> = RunContext<C> & {
   reuse?: { runDir: string; outcomes: Record<string, PathOutcome> };
   /** Receives progress lines; writes to stdout when omitted. */
   log?: (line: string) => void;
+  /** Receives privacy-checked manifest snapshots as paths and steps change. */
+  onProgress?: (manifest: Manifest) => void;
 };
 ```