@crvouga/atlas 0.0.0-stage → 0.2.0

package/packages/bun/README.md

@@ -0,0 +1,69 @@
+# @crvouga/atlas/bun
+
+A [Bun WebView](https://bun.com/docs/runtime/webview) driver for [Atlas](../../README.md): run
+statecharts against a web app in Bun's built-in headless browser. On macOS it is the system WebKit
+(`WKWebView`), so there is nothing to download; elsewhere Bun drives an installed Chrome, Chromium,
+Edge or Brave over the DevTools Protocol. A view starts in milliseconds and a screenshot takes
+about ten, which makes it the quickest way to run a chart against a real page.
+
+```sh
+bun add -d @crvouga/atlas
+bun --bun atlas run --config atlas.config.ts
+```
+
+It needs the Bun runtime with Bun.WebView, which is experimental (tested on Bun 1.4.2). The `atlas` binary runs
+under Bun as it is. FFmpeg on the `PATH` is needed for clips.
+
+## Use
+
+```ts
+import { defineConfig } from '@crvouga/atlas';
+import type { WebViewContext } from '@crvouga/atlas/bun';
+import { bunWebViewDriver, label, role, screen, text } from '@crvouga/atlas/bun';
+
+export default defineConfig<WebViewContext>({
+  specs: './specs',
+  driver: bunWebViewDriver({ baseUrl: 'http://127.0.0.1:3000' }),
+  targets: ['http://127.0.0.1:3000'],
+  implementation: {
+    setup: (ctx) => ctx.goto('/'),
+    events: {
+      'Adds a todo': {
+        kind: 'user',
+        how: 'Types a todo and taps "Add".',
+        async run({ user }) {
+          await user.type(label('New todo'), 'Water the plants', 'New todo');
+          await user.tap(role('button', 'Add', { exact: true }), 'Add');
+        }
+      }
+    },
+    states: {
+      'No todos': screen({ all: [text('Nothing to do yet')] }),
+      'Some todos open': screen({ all: [text(/^\d+ left$/)] })
+    }
+  }
+});
+```
+
+## What it provides
+
+- **`bunWebViewDriver(options)`**: a fresh view per path attempt (390×844 by default; `width`,
+  `height`), `backend` (`webkit` or `chrome`), `baseUrl` for `goto`, `actionTimeoutMs` for how long
+  a tap waits for its target, and showcase `pacing`.
+- **`WebViewContext`**: the `view` itself, `goto`, `evaluate`, `find(signal)` (where a signal is on
+  screen) and `user.tap` / `user.type` / `user.press`, which log to the step's timeline with the tap
+  position. It is a `SignalContext`, so implementations written against `@crvouga/atlas/signals`
+  run here and on Playwright, WebDriver and Detox alike.
+- **`screen({ all, any, none, checks, transient, sameAs, lookIn, settle })`** and the signals
+  `testId`, `role`, `label`, `text`, `css`. Signals resolve in the page with the WAI-ARIA implicit
+  roles of common elements and their accessible names.
+- **Media**: PNG screenshots of the viewport; in showcase mode a clip per transition, encoded from
+  screenshots (about 30 frames a second) as H.264 MP4.
+
+Bun.WebView has no fake clock and no init scripts, so a time event uses the app's own controls
+(or runs on Playwright, whose clock can jump). Playwright also runs under Bun, so a single run can
+put one client in Bun's WebKit and another in Playwright's Chromium (`combineDrivers`).
+
+## License
+
+MIT

package/packages/core/README.md

@@ -0,0 +1,78 @@
+# @crvouga/atlas
+
+Executable statecharts. Load charts in W3C SCXML or XState v5 machine config, compose child charts,
+lint them, plan paths that cover every transition, run those paths against a real system through
+any driver, and write a manifest with JUnit, CTRF, Mermaid and WebVTT alongside.
+
+```sh
+bun add -d @crvouga/atlas
+```
+
+Runs on Bun, or on Node 22.18 or later.
+
+## Use
+
+```ts
+// atlas.config.ts
+import { defineConfig, functionDriver } from '@crvouga/atlas';
+
+import { Door } from './door';
+
+export default defineConfig<Door>({
+  specs: './specs',
+  driver: functionDriver(() => new Door()),
+  implementation: {
+    setup: async () => undefined,
+    events: {
+      Opens: { kind: 'user', how: 'door.open()', run: async (door) => door.open() },
+      Closes: { kind: 'user', how: 'door.close()', run: async (door) => door.close() }
+    },
+    states: {
+      Closed: { recognize: async (door) => ({ matched: !door.isOpen, signals: [] }) },
+      Open: { recognize: async (door) => ({ matched: door.isOpen, signals: [] }) }
+    }
+  }
+});
+```
+
+```sh
+atlas lint --require-implementations
+atlas plan
+atlas run --mode fast
+atlas export --specs ./specs --format mermaid
+```
+
+## API
+
+| Export | Purpose |
+| --- | --- |
+| `defineConfig`, `prepare`, `runConfig`, `mergeConfigRuns` | Typed config; load + lint + plan; run and write reports; compose runs |
+| `loadSpecDirectory`, `parseChart`, `parseJourneys`, `bundleOf` | Read charts and journeys |
+| `scxmlToMachine`, `machineToScxml`, `scxmlToken`, `ATLAS_NS` | SCXML ↔ XState config |
+| `composeCharts` | Inline invoked child charts into one machine, with their hand-offs |
+| `lintBundle` | Purity, reachability, dead ends, journeys, implementations |
+| `chartScope`, `planChart`, `runnableSteps`, `pathKey` | What a run covers and the paths that cover it, from seeds; stable path keys |
+| `ChartGraph` | A pure simulator: replay, explore, which transitions an event fires |
+| `runPaths`, `functionDriver`, `Timeline` | The runner (seeds, a worker pool) and the simplest driver |
+| `buildManifest`, `writeRun`, `mergeRuns`, `shardPaths`, `readOutcomes`, `latestRun`, `durationHistory` | Fold outcomes into a manifest in plan order; shards, merges and reruns |
+| `httpDriver`, `httpClient` | An HTTP API client as a driver: base URL, cookie jar, every call on the timeline |
+| `combineDrivers`, `combineImplementations`, `onClient` | Several clients in one run (a phone, a web dashboard, an API), each on its own driver |
+| `recordFrames` | Clips encoded from screenshots, for drivers without a screen recorder |
+| `cloudEventsHttpSource`, `cloudEventsFromHttp`, `logFileSource`, `compareBusinessEvents`, `correlated` | Business events |
+| `DEFAULT_PRIVACY`, `mergePrivacy`, `privacyFindings`, `assertAllowedTarget` | Privacy rules |
+| `toJUnit`, `toCtrf`, `toWebVtt`, `toMermaid` | Report formats |
+
+`@crvouga/atlas/spec` exports the browser-safe part (types, parsing, SCXML conversion and
+composition) with no Node built-ins.
+
+`@crvouga/atlas/signals` exports the driver-neutral screen vocabulary: the signals (`testId`,
+`role`, `label`, `text`, `css`), `SignalContext` (what the Playwright, Bun, WebDriver and Detox
+contexts all provide), `screen` (a recogniser for any `SignalContext`), `signatureScreen` (build
+`screen` for a new driver) and `DOM_PROBE` (resolve a signal inside a page).
+
+Spec conventions, the driver interface, the config reference and the manifest are documented in the
+[Atlas README](../../README.md).
+
+## License
+
+MIT

package/packages/core/bin/atlas.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+if (!globalThis.Bun) {
+  const { register } = await import('tsx/esm/api');
+  register();
+}
+// By package name, so the CLI and the config it loads share one copy of Atlas.
+const { main } = await import('@crvouga/atlas/cli');
+process.exitCode = await main();

package/packages/detox/README.md

@@ -0,0 +1,73 @@
+# @crvouga/atlas/detox
+
+A Detox driver for [Atlas](../../README.md): run statecharts against an iOS or Android app.
+
+```sh
+bun add -d @crvouga/atlas detox
+```
+
+Detox is an optional peer dependency: the driver types Detox's globals structurally, so the package
+builds without it.
+
+## Use
+
+Run Atlas from inside a Detox test, where Detox's `device`, `element`, `by` and `waitFor` globals
+exist:
+
+```ts
+import { defineConfig, runConfig } from '@crvouga/atlas';
+import type { DetoxContext } from '@crvouga/atlas/detox';
+import { detoxDriver, detoxScreen } from '@crvouga/atlas/detox';
+
+const config = defineConfig<DetoxContext>({
+  specs: './specs',
+  driver: detoxDriver({ launchArgs: { resetData: true } }),
+  implementation: {
+    setup: async () => undefined,
+    events: {
+      'Adds a todo': {
+        kind: 'user',
+        how: 'Types a todo and taps "Add".',
+        async run(ctx) {
+          await ctx.type(ctx.by.id('new-todo'), 'Water the plants', 'New todo');
+          await ctx.tap(ctx.by.text('Add'), 'Add');
+        }
+      }
+    },
+    states: {
+      'No todos': detoxScreen({ all: [{ matcher: by.text('Nothing to do yet'), name: 'empty message' }] }),
+      'Some todos open': detoxScreen({
+        all: [{ matcher: by.id('todo-list'), name: 'todo list' }],
+        none: [{ matcher: by.text('Nothing to do yet'), name: 'empty message' }]
+      })
+    }
+  }
+});
+
+it('follows the todo statechart', async () => {
+  const { ok } = await runConfig(config, { mode: 'fast' });
+  expect(ok).toBe(true);
+}, 30 * 60_000);
+```
+
+## What it provides
+
+- **`detoxDriver({ api?, launchArgs? })`**: relaunches the app (`newInstance: true`) for every path
+  attempt and terminates it afterwards; screenshots come from `device.takeScreenshot`. Pass `api` to
+  use something other than the globals.
+- **`DetoxContext`**: Detox's `device`, `element`, `by` and `waitFor`, plus `tap(matcher, label)` and
+  `type(matcher, text, label)`, which log each action to the step's timeline. It is a
+  `SignalContext` too (`goto` opens a deep link, `isVisible`, `user.tap`, `user.type`), so an
+  implementation written against `@crvouga/atlas/signals` runs here unchanged; `detoxMatcher`
+  maps a signal to `by.id`, `by.label` or `by.text`.
+
+To combine a native app with other clients (a web dashboard, an API) from the `atlas` CLI rather
+than from inside a Detox test, use `@crvouga/atlas/webdriver` with Appium.
+- **`detoxScreen({ all, none, checks })`**: a state recogniser from Detox matchers.
+
+Detox records video per test through its artifacts plugin rather than per call, so this driver does
+not record a clip per transition; run Detox with `--record-videos` to keep a video of each attempt.
+
+## License
+
+MIT

package/packages/playwright/README.md

@@ -0,0 +1,77 @@
+# @crvouga/atlas/playwright
+
+A Playwright driver for [Atlas](../../README.md): run statecharts against a web app (or a React
+Native app on the web), recognise screens from UI signals, and record showcase media.
+
+```sh
+bun add -d @crvouga/atlas playwright
+bunx playwright install chromium
+```
+
+FFmpeg on the `PATH` is needed for clips and WebP thumbnails.
+
+## Use
+
+```ts
+import { defineConfig } from '@crvouga/atlas';
+import type { PlaywrightContext } from '@crvouga/atlas/playwright';
+import { css, playwrightDriver, role, screen, testId, text } from '@crvouga/atlas/playwright';
+
+export default defineConfig<PlaywrightContext>({
+  specs: './specs',
+  driver: () => playwrightDriver({ clock: true }),
+  targets: ['http://127.0.0.1:3000'],
+  implementation: {
+    setup: ({ page }) => page.goto('http://127.0.0.1:3000').then(() => undefined),
+    events: {
+      'Signs in': {
+        kind: 'user',
+        how: 'Types the test account and taps "Sign in".',
+        async run({ page, user }) {
+          await user.type(page.getByLabel('Email'), 'sam@example.com', 'Email');
+          await user.tap(page.getByRole('button', { name: 'Sign in' }), 'Sign in');
+        }
+      },
+      'Session expires': {
+        kind: 'time',
+        how: 'Jumps the clock an hour.',
+        run: ({ page }) => page.clock.fastForward('01:00:00')
+      }
+    },
+    states: {
+      Home: screen({ all: [role('heading', 'Home')], none: [text('Sign in')] }),
+      'Signed out': screen({
+        all: [role('button', 'Sign in')],
+        checks: [{ check: 'Explains the session ended', signal: testId('session-ended') }]
+      }),
+      Saving: screen({ all: [css('[aria-busy="true"]')], transient: true })
+    }
+  }
+});
+```
+
+## What it provides
+
+- **`playwrightDriver(options)`**: a fresh browser context per path attempt; a 390×844 phone at
+  device scale factor 3 with touch by default (`device`); `launch` options; `clock: true` installs
+  Playwright's fake clock before the app loads, so time events can call `page.clock.fastForward`;
+  a Playwright trace for failed attempts (`traceOnFailure`, default on); `onPage` to prepare each
+  page; `pacing` to tune showcase timing.
+- **`PlaywrightContext`**: `{ page, context, browser, user, goto, isVisible }`, a `SignalContext`
+  (see `@crvouga/atlas/signals`), so implementations written against signals run here and on the
+  Bun, WebDriver and Detox drivers alike. `user.tap(target, label)` and
+  `user.type(target, text, label)` take a Playwright locator or a signal, and log to the step's
+  timeline; in showcase mode they move a soft touch indicator to the target, pause like a person
+  and type at human speed. `goto` resolves paths against `baseUrl`.
+- **`screen({ all, any, none, checks, transient, sameAs, lookIn, settle })`**: a state recogniser
+  from a UI signature. Every `all` signal visible, at least one `any`, no `none`.
+- **Signals**: `testId(id)`, `role(role, name?, { exact? })`, `text(string | RegExp, { exact? })`,
+  `label(string | RegExp)`, `css(selector)`, the same values every driver resolves. Prefer roles,
+  labels and text as a person would; reach for test ids last.
+- **Media**: screenshots at the device's physical resolution with the touch layer hidden, plus WebP
+  thumbnails; in showcase mode a clip per transition, captured at device resolution and encoded as
+  H.264 MP4 with a poster frame.
+
+## License
+
+MIT

package/packages/reports/README.md

@@ -0,0 +1,47 @@
+# Atlas reports
+
+Atlas owns reusable evidence publication, storage, retention, APIs, report navigation and snapshot interpretation. All nondeterministic work is provided through structural `ObjectStore`, `Clock`, `Timers` and `HttpClient` ports. There are no consumer-repository dependencies.
+
+Consumers capture `RunReport` timelines and use `publishSource`, `publishPart` and `publishInventory` to publish them. Existing commit-keyed and compressed report stores remain readable, including reusable sources and independent producer evidence. `createReportsApp` mounts a read-only Hono API over injected stores; it is hosted alongside Atlas, not the product under test.
+
+The Atlas visualizer shows each kind of spec in its own tab, with every spec's recorded outcome in the index: Gherkin rules, scenarios and example tables with the result of each scenario, Quint declarations with their recorded traces, DMN decision tables, and the checks of any other document. Each result keeps its origin, measurements, recorded steps, per-actor snapshots, action targets and timings. Missing evidence is never interpreted as a passing result.
+
+`exportEvidence({ fetch, target })` copies a reports API into the static layout consumed by the visualizer, preserving layer provenance and captured files. It returns the list of unavailable artifacts. The caller provides a fresh output store; it must not publish the export until it completes.
+
+## Combining evidence
+
+Current specs define the outline. `combineEvidence` fills it with the newest completed result for each producer, check and parameter set, across backends, branches and commits. Equal-time conflicts favor failure. Unfinished runs do not erase completed outcomes. Missing specs stay visible and removed specs retain their evidence outside the outline. `evidenceView` groups those results by check: the outcomes, the recorded timings that qualify them, and a summary per spec. A timing over its allowance never fails a check. `checkHistory` returns every layer's own record of one check, so a superseded result stays readable. Leaving a backend, a branch or one layer out (`contributes`) is how earlier outcomes are inspected.
+
+## Backends
+
+`createReportsApp` combines layers from several stores. `localStore` is the backend `local` ("This machine"), `store` is `shared` ("Shared reports"), and `backends` adds any number of further named stores, such as another team's bucket or a device lab. Every layer says which backend it came from. An unavailable backend is named in the page's notices and leaves the others usable; `GET /evidence?retry=1` asks it again without waiting.
+
+| Route | Returns |
+| --- | --- |
+| `GET /evidence` | A bounded page of layer origins and totals (`LayerHeader`), the backends, the running suites and any notices. `?cursor=` reads the next, older page. |
+| `GET /evidence/rows/:backend/:id` | One layer's checks (`LayerRow`) and recorded spec fingerprints. Immutable layers are cacheable forever. |
+| `GET /layers/:id/…` | An archived layer's `frame.css`, `tests/<test>/report.json` and `tests/<test>/files/<path>`. |
+| `GET /live/:source/…` | The same files of a suite that is still running. |
+| `GET /outline`, `GET /outline/spec?path=` | The current specs, their fingerprints, and one document. |
+
+The index is small and is what a viewer polls. A layer's checks are read once and never again for an immutable layer. Recording blobs load only when opened. Existing commit-addressed recordings are discovered in place and deduplicated against their archived layers by execution. No automatic branch-based pruning removes accumulated evidence.
+
+## Results while a suite runs
+
+A producer announces a running suite by writing `{ packageDir, bucket, startedAtMs, plannedChecks? }` under `active/` in the local store, and removes it when the suite ends. Given `live: { bucket, origin?, frameCss? }`, the API reads the tests that suite has finished from the bucket it writes into and serves them as one live layer (`live-<source>`), so each result appears when its test ends, not when its package does. Its recordings are readable under `/live/<source>/`. When the suite ends, its live layer stays until the collected layer for the same producer appears, or thirty seconds pass. A live layer is never exported.
+
+The reports API composes its remote store as the authoritative primary with a local filesystem cache. Reads populate ordered cache tiers, writes reach the primary before caches, cache write failures do not hide successful durable writes, and remote listings remain authoritative with a short in-process cache. Cache entries expire quickly so other publishers' updates appear; on a remote outage the dev viewer may serve a previously observed cached report. Objects above the cache size limit bypass local copying.
+
+Spec runs persist each completed test timeline as it finishes, including failed timelines. The package collector still publishes the partial report and failed suite verdict.
+
+Freshness warnings preserve the recorded outcome. Changed spec fingerprints or related working-tree files warn; missing fingerprints are unknown, and a different commit warns when related code has not been compared. No rerun is implied. This deliberately favors quick, potentially stale evidence over a consistent fresh execution; release verification remains separate.
+
+## Standalone development
+
+Configure `ATLAS_REPORTS_MODULE` with a host composition module exporting `reportsDevFetch(request, repoRoot)`. Atlas's Vite middleware serves it at `/api/reports`, alongside specs and chart runs. `INIT_CWD` identifies the consuming repository. Credentials stay in that server module.
+
+For a separately hosted reports API, set `VITE_ATLAS_REPORTS_URL` when building the visualizer. Otherwise a built site reads `data/evidence/`, populated with `exportEvidence`. Atlas still browses specs if evidence is absent.
+
+## Verification
+
+`bun test tests` exercises this package without a consumer. The visualizer runs `bun run test:reports` for automated DOM and parsing checks. Consumers should retain black-box integration suites for their object-store and harness adapters. The migrated reporting contracts are in `specs/developer-tools/` at the Atlas root.

package/packages/reports/STORAGE.md

@@ -0,0 +1,73 @@
+# Report storage and producers
+
+Atlas owns the object-store protocol shared by publication, APIs and the visualizer. Every operation receives its
+storage and time ports from its caller.
+
+## Immutable layers
+
+`layers/index/<inverted-time>-<digest>.json` discovers immutable manifests at `layers/manifests/<digest>.json`. Each records producer, origin, parameters, checks, spec fingerprints and a recording bundle. The manifest is written after its blobs and the index last. Distinct results at the same timestamp retain separate identities. Compressed blobs under `layers/blobs/` are addressed by content and reused across runs; ordinary source publication shares its bundle directly with its layer without recompressing snapshots.
+
+Git commits are provenance and exact historical recording addresses, never a report partition. `combineEvidence` chooses completed results per check and parameters, retaining gaps from older layers. `publishSource` accepts `parameters`, and standalone parts may include them too. Inventory must be published before results for fingerprint comparison to be available.
+
+## Commit inventory
+
+`publishInventory(store, { sha, documents })` stores every specification body
+before writing `commits/<sha>/inventory.json`. Files retain their relative path,
+context, type and title, including features, models, health obligations and
+supporting documents. Reads validate commit identity and restrict document
+access to that inventory. Inventories are independent of test-run attempts.
+Document publication uses at most sixteen concurrent writes and drains them
+before publishing the inventory.
+
+## Independent report parts
+
+`publishPart(store, part)` accepts:
+
+```ts
+{
+  sha: '…',            // full 40-character commit hash
+  id: 'browser-paint', // stable producer identifier
+  kind: 'performance',// open category; new categories need no viewer change
+  title: 'Browser paint',
+  recordedAtMs: 123,
+  checks: [{
+    id: 'home-lcp', title: 'Home paint', status: 'passed',
+    detail: 'Measured by the browser performance contract',
+    specPath: 'specs/example/paint.feature',
+    measurements: [{ name: 'LCP', value: 1400, unit: 'ms', limit: 2500 }]
+  }]
+}
+```
+
+Statuses are `passed`, `failed`, `running` or `not-run`. Empty parts are
+`not-run`. Values must be finite; producer identities, statuses, commit hashes
+and duplicate check identifiers are validated before publication.
+
+Each producer writes its own content-addressed key beneath
+`commits/<sha>/parts/<id>/`. The latest timestamp wins per producer. Tied
+publications are deterministic and favor failure over success. A per-commit
+`versions/<sha>.json` marker discovers evidence without requiring a behavior
+run. Independent parts never replace or close that run.
+
+`readParts` and `latestParts` aggregate the results. A new `kind` appears as an
+additional explorer section. `specPath` connects a check to its specification;
+a source-qualified check id connects it to an existing timeline. A standalone
+producer can use any check id and display measurements without a timeline.
+
+## Recorded sources
+
+`publishSource` retains test-runner outcomes and snapshots. Optional producer
+output in its local `part.json` has `{ kind, title, checks }` without commit or
+publication metadata. It travels with reusable source content. Behavior sources
+also retain a separate recorded-action performance output. `sourceParts` binds
+these outputs to a commit and source-qualified timeline ids; the publication
+adapter records each part independently.
+
+The existing selected-attempt pointer, reusable content hashes and frame bundles
+continue to own test-run publication. An empty closed run is `skipped`, never a
+successful result inferred from absent evidence. Retention keeps historical evidence and its referenced content, including previous attempts and deleted branches. `pruneReports` reports retained commits and deletes nothing; storage usage grows with unique evidence.
+
+Large bundles overlap at most four 4 MiB chunk uploads per source. Entry parts
+retain input order even when uploads complete out of order. Backpressure bounds
+buffered chunks, and failures drain started uploads without publishing an index
+that names incomplete content.

package/packages/schema/README.md

@@ -0,0 +1,23 @@
+# @crvouga/atlas/schema
+
+The Atlas contract, as Zod schemas and as JSON Schema (draft 2020-12) documents in `schemas/`:
+
+| Schema | Describes |
+| --- | --- |
+| `state-node.schema.json` | One state of an XState machine config, with the `meta` fields Atlas reads |
+| `journeys.schema.json` | `journeys.yaml`: named event sequences through a chart |
+| `atlas.schema.json` | `atlas.yaml`: the optional product map (contexts, hand-offs, exclusions) |
+| `manifest.schema.json` | `manifest.json`: one run, its states, transitions, paths and coverage |
+| `state-record.schema.json`, `transition-record.schema.json`, `path-record.schema.json` | Records inside a manifest |
+| `timeline-entry.schema.json` | One step of a clip's timeline (taps, typing, system events) |
+| `cloud-event.schema.json` | A CloudEvents 1.0 business event a run observed |
+| `runs-index.schema.json` | `runs/index.json`: the runs a host serves |
+
+Regenerate the JSON Schemas after changing a Zod schema:
+
+```sh
+bun run schemas
+```
+
+Readers validate each record on its own and keep the ones that parse, so a newer or partly broken
+manifest still renders what it can.

package/packages/schema/schemas/atlas-change.schema.json

@@ -0,0 +1,34 @@
+{
+  "$id": "https://github.com/crvouga/atlas/schemas/atlas-change.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "scope": {
+      "type": "string",
+      "enum": [
+        "specs",
+        "runs"
+      ]
+    },
+    "files": {
+      "default": [],
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "runIds": {
+      "default": [],
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "sourceId": {
+      "type": "string"
+    }
+  },
+  "required": [
+    "scope"
+  ]
+}

package/packages/schema/schemas/atlas.schema.json

@@ -0,0 +1,32 @@
+{
+  "$id": "https://github.com/crvouga/atlas/schemas/atlas.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "schemaVersion": {
+      "type": "integer",
+      "minimum": -9007199254740991,
+      "maximum": 9007199254740991
+    },
+    "title": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "contexts": {
+      "type": "array",
+      "items": {}
+    },
+    "handOffs": {
+      "type": "array",
+      "items": {}
+    },
+    "excluded": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    }
+  }
+}

package/packages/schema/schemas/cloud-event.schema.json

@@ -0,0 +1,40 @@
+{
+  "$id": "https://github.com/crvouga/atlas/schemas/cloud-event.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "specversion": {
+      "type": "string",
+      "const": "1.0"
+    },
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "source": {
+      "type": "string",
+      "minLength": 1
+    },
+    "type": {
+      "type": "string",
+      "minLength": 1
+    },
+    "time": {
+      "type": "string"
+    },
+    "subject": {
+      "type": "string"
+    },
+    "datacontenttype": {
+      "type": "string"
+    },
+    "data": {}
+  },
+  "required": [
+    "specversion",
+    "id",
+    "source",
+    "type"
+  ],
+  "additionalProperties": {}
+}

package/packages/schema/schemas/journeys.schema.json

@@ -0,0 +1,17 @@
+{
+  "$id": "https://github.com/crvouga/atlas/schemas/journeys.schema.json",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "journeys": {
+      "type": "object",
+      "propertyNames": {
+        "type": "string"
+      },
+      "additionalProperties": {}
+    }
+  },
+  "required": [
+    "journeys"
+  ]
+}