@crvouga/atlas 0.0.0-stage → 0.2.0

package/dist/reports/src/source-reader.js

@@ -0,0 +1,17 @@
+import { bundleIndexKey, createBundleReader, readBundleIndex } from './bundle.js';
+export async function sourceReader(store, args) {
+    const index = await readBundleIndex(store, bundleIndexKey(args.sha, args.source));
+    if (Object.keys(index).length > 0)
+        return createBundleReader(store, index);
+    // Existing stored reports remain readable while writers use bundles.
+    return async (key) => {
+        const obj = await store.get(key);
+        return obj === null
+            ? null
+            : {
+                key,
+                contentType: obj.contentType,
+                bytes: new Uint8Array(await new Response(obj.body).arrayBuffer()),
+            };
+    };
+}

package/dist/reports/src/spec-evidence.d.ts

@@ -0,0 +1,6 @@
+import type { HtmlReportTest } from './recording-bundle.js';
+import type { SpecEntry } from './explorer-types.js';
+/** Resolve original spec paths, including runner absolute paths, without matching another document. */
+export declare function testsForSpec(entry: SpecEntry, tests: readonly HtmlReportTest[]): readonly HtmlReportTest[];
+/** Build once for the inventory; large suites never scan all tests per row. */
+export declare function specEvidenceCounts(tests: readonly HtmlReportTest[]): ReadonlyMap<string, number>;

package/dist/reports/src/spec-evidence.js

@@ -0,0 +1,20 @@
+/** Resolve original spec paths, including runner absolute paths, without matching another document. */
+export function testsForSpec(entry, tests) {
+    return tests.filter((test) => {
+        const path = test.report.meta.sourceFile?.replaceAll('\\', '/') ?? '';
+        return path === entry.path || path.endsWith(`/${entry.path}`);
+    });
+}
+/** Build once for the inventory; large suites never scan all tests per row. */
+export function specEvidenceCounts(tests) {
+    const counts = new Map();
+    for (const test of tests) {
+        const source = test.report.meta.sourceFile?.replaceAll('\\', '/');
+        if (!source)
+            continue;
+        const at = source.indexOf('specs/');
+        const path = at < 0 ? source : source.slice(at);
+        counts.set(path, (counts.get(path) ?? 0) + 1);
+    }
+    return counts;
+}

package/dist/reports/src/spec-inventory.d.ts

@@ -0,0 +1,14 @@
+import type { ObjectStore } from './object-store.js';
+import type { SpecEntry, SpecInventory } from './explorer-types.js';
+export declare function isSpecPath(path: string): boolean;
+export declare function specEntry(path: string, content: string): SpecEntry;
+/** Publish document bodies first; an inventory always names readable content. */
+export declare function publishInventory(store: ObjectStore, args: {
+    readonly sha: string;
+    readonly documents: readonly {
+        readonly path: string;
+        readonly content: string;
+    }[];
+}): Promise<SpecInventory>;
+export declare function readInventory(store: ObjectStore, sha: string): Promise<SpecInventory | null>;
+export declare function readSpecDocument(store: ObjectStore, sha: string, path: string): Promise<string | null>;

package/dist/reports/src/spec-inventory.js

@@ -0,0 +1,75 @@
+import { textFingerprint } from './layer-merge.js';
+import { readUtf8, writeUtf8 } from './object-io.js';
+import { eachLimited } from './completion-order.js';
+import { recordExplorerVersion } from './explorer-versions.js';
+import { isCommitSha } from './keys.js';
+export function isSpecPath(path) {
+    return (path.startsWith('specs/') &&
+        path
+            .split('/')
+            .every((part) => part.length > 0 &&
+            part !== '.' &&
+            part !== '..' &&
+            !/[\\\u0000-\u001f]/.test(part)));
+}
+export function specEntry(path, content) {
+    if (!isSpecPath(path))
+        throw new Error('Invalid spec path');
+    const file = path.split('/').at(-1) ?? path;
+    const kind = file.endsWith('.openslo.yaml')
+        ? 'openslo'
+        : (file.split('.').at(-1) ?? 'document');
+    const title = /^\s*Feature:\s*(.+)$/m.exec(content)?.[1] ??
+        /^#\s+(.+)$/m.exec(content)?.[1] ??
+        file;
+    return {
+        path,
+        fingerprint: textFingerprint(content),
+        domain: path.split('/').length > 2 ? path.split('/')[1] : 'Overview',
+        kind,
+        title,
+    };
+}
+function inventoryKey(sha) {
+    if (!isCommitSha(sha))
+        throw new Error('Invalid commit');
+    return `commits/${sha}/inventory.json`;
+}
+function documentKey(sha, path) {
+    if (!isSpecPath(path))
+        throw new Error('Invalid spec path');
+    inventoryKey(sha);
+    return `commits/${sha}/specs/${encodeURIComponent(path)}`;
+}
+/** Publish document bodies first; an inventory always names readable content. */
+export async function publishInventory(store, args) {
+    const entries = args.documents
+        .map((doc) => specEntry(doc.path, doc.content))
+        .sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    if (new Set(entries.map((entry) => entry.path)).size !== entries.length)
+        throw new Error('Duplicate spec');
+    await eachLimited(args.documents, 16, async (doc) => {
+        await writeUtf8(store, documentKey(args.sha, doc.path), doc.content, 'text/plain; charset=utf-8');
+    });
+    const inventory = { sha: args.sha, entries };
+    await writeUtf8(store, inventoryKey(args.sha), JSON.stringify(inventory), 'application/json');
+    await recordExplorerVersion(store, args.sha);
+    return inventory;
+}
+export async function readInventory(store, sha) {
+    const raw = await readUtf8(store, inventoryKey(sha));
+    if (raw === null)
+        return null;
+    const inventory = JSON.parse(raw);
+    if (inventory.sha !== sha ||
+        !Array.isArray(inventory.entries) ||
+        inventory.entries.some((entry) => !isSpecPath(entry.path)))
+        throw new Error('Invalid spec inventory');
+    return inventory;
+}
+export async function readSpecDocument(store, sha, path) {
+    const inventory = await readInventory(store, sha);
+    if (!inventory?.entries.some((entry) => entry.path === path))
+        return null;
+    return readUtf8(store, documentKey(sha, path));
+}

package/dist/reports/src/status.d.ts

@@ -0,0 +1,4 @@
+import type { ReportTestStatus } from './report-types.js';
+export declare function suiteStatus(tests: readonly {
+    readonly status: ReportTestStatus;
+}[]): ReportTestStatus;

package/dist/reports/src/status.js

@@ -0,0 +1,8 @@
+export function suiteStatus(tests) {
+    if (tests.some((t) => t.status === 'failed'))
+        return 'failed';
+    if (tests.length > 0 && tests.every((t) => t.status === 'skipped')) {
+        return 'skipped';
+    }
+    return 'passed';
+}

package/dist/reports/src/store-prefix.d.ts

@@ -0,0 +1,21 @@
+import type { ObjectStore, StoredObject } from './object-store.js';
+export declare function normalizeObjectStorePrefix(prefix: string): string;
+/**
+ * Decorator that scopes every {@link ObjectStore} operation to a fixed key
+ * prefix. Used at composition roots (e.g. API bindings) so feature code uses
+ * logical keys while a shared bucket stays partitioned by prefix.
+ */
+export declare class ObjectStoreWithPrefix implements ObjectStore {
+    private readonly inner;
+    private readonly prefix;
+    constructor(inner: ObjectStore, prefix: string);
+    private scopedKey;
+    get(key: string): Promise<StoredObject | null>;
+    put(key: string, bytes: Uint8Array, contentType: string): Promise<void>;
+    head(key: string): Promise<boolean>;
+    delete(key: string): Promise<void>;
+    deleteMany(keys: readonly string[]): Promise<void>;
+    getUri(key: string): Promise<string | null>;
+    listKeys(prefix?: string): Promise<readonly string[]>;
+    withPrefix(subPrefix: string): ObjectStore;
+}

package/dist/reports/src/store-prefix.js

@@ -0,0 +1,53 @@
+import { assertLogicalObjectKey } from './namespace-guard.js';
+export function normalizeObjectStorePrefix(prefix) {
+    if (prefix.length === 0) {
+        throw new Error('ObjectStoreWithPrefix: prefix must be non-empty');
+    }
+    return prefix.endsWith('/') ? prefix : `${prefix}/`;
+}
+function joinObjectStorePrefixes(left, right) {
+    return normalizeObjectStorePrefix(`${left}${normalizeObjectStorePrefix(right)}`);
+}
+/**
+ * Decorator that scopes every {@link ObjectStore} operation to a fixed key
+ * prefix. Used at composition roots (e.g. API bindings) so feature code uses
+ * logical keys while a shared bucket stays partitioned by prefix.
+ */
+export class ObjectStoreWithPrefix {
+    inner;
+    prefix;
+    constructor(inner, prefix) {
+        this.inner = inner;
+        this.prefix = normalizeObjectStorePrefix(prefix);
+    }
+    scopedKey(key) {
+        assertLogicalObjectKey(key);
+        return `${this.prefix}${key}`;
+    }
+    get(key) {
+        return this.inner.get(this.scopedKey(key));
+    }
+    put(key, bytes, contentType) {
+        return this.inner.put(this.scopedKey(key), bytes, contentType);
+    }
+    head(key) {
+        return this.inner.head(this.scopedKey(key));
+    }
+    delete(key) {
+        return this.inner.delete(this.scopedKey(key));
+    }
+    deleteMany(keys) {
+        return this.inner.deleteMany(keys.map((key) => this.scopedKey(key)));
+    }
+    getUri(key) {
+        return this.inner.getUri(this.scopedKey(key));
+    }
+    async listKeys(prefix = '') {
+        const scopedPrefix = `${this.prefix}${prefix}`;
+        const keys = await this.inner.listKeys(scopedPrefix);
+        return keys.map((k) => k.slice(this.prefix.length));
+    }
+    withPrefix(subPrefix) {
+        return new ObjectStoreWithPrefix(this.inner, joinObjectStorePrefixes(this.prefix, subPrefix));
+    }
+}

package/dist/reports/src/test-catalog-entity.d.ts

@@ -0,0 +1,3 @@
+import type { HtmlReportTest } from './recording-bundle.js';
+import type { CatalogEntity } from './catalog.js';
+export declare function testCatalogEntity(test: HtmlReportTest): CatalogEntity;

package/dist/reports/src/test-catalog-entity.js

@@ -0,0 +1,34 @@
+import { fileLabel } from './format.js';
+function packageOf(testId) {
+    const source = testId.split('/')[0] ?? '';
+    const cut = source.indexOf('--');
+    const name = cut < 0 ? source : source.slice(0, cut);
+    return name.length > 0 ? name : 'report';
+}
+export function testCatalogEntity(test) {
+    const meta = test.report.meta;
+    const file = fileLabel(meta.sourceFile);
+    const packageName = packageOf(meta.testId);
+    const error = meta.error?.split('\n')[0] ?? '';
+    return {
+        id: meta.testId,
+        title: meta.title,
+        status: meta.status,
+        durationMs: meta.durationMs,
+        file,
+        packageName,
+        runtime: meta.runtime,
+        detail: error,
+        search: [
+            meta.title,
+            meta.testId,
+            meta.sourceFile ?? '',
+            file,
+            meta.system,
+            meta.runtime,
+            packageName,
+            error,
+        ].join(' '),
+        href: null,
+    };
+}

package/dist/reports/src/types.d.ts

@@ -0,0 +1,5 @@
+import type { HtmlReportBundle } from './recording-bundle.js';
+/** Bundle plus document title for the standalone / Solid report viewer. */
+export type ReportData = HtmlReportBundle & {
+    readonly title: string;
+};

package/dist/reports/src/use-report-nav.d.ts

@@ -0,0 +1,25 @@
+import type { Timers } from './clock.js';
+import type { FlatFrame } from './frames.js';
+import type { Route } from './hash.js';
+import type { ReportData } from './types.js';
+import type { Accessor } from 'solid-js';
+import type { ReportNavigation } from './navigation.js';
+export type ReportNav = {
+    route: Accessor<Route>;
+    showHelp: Accessor<boolean>;
+    showPalette: Accessor<boolean>;
+    playing: Accessor<boolean>;
+    navigate: (route: Route, replace?: boolean) => void;
+    /** Write the in-memory route to the URL now (end of a scrub drag). */
+    commitHash: () => void;
+    setParam: (key: string, value: string) => void;
+    goFrame: (frame: FlatFrame | null, node?: string | undefined) => void;
+    stepFrame: (delta: number) => void;
+    toggleHelp: () => void;
+    closeHelp: () => void;
+    togglePalette: () => void;
+    closePalette: () => void;
+    togglePlay: () => void;
+    stopPlay: () => void;
+};
+export declare function useReportNav(data: ReportData, navigation: ReportNavigation, timers: Timers): ReportNav;

package/dist/reports/src/use-report-nav.js

@@ -0,0 +1,181 @@
+import { selectedFrame, testFrames } from './frames.js';
+import { buildHash, parseHash } from './hash.js';
+import { onReportKeyDown } from './keyboard.js';
+import { createEffect, createSignal, onCleanup } from 'solid-js';
+function advancePlay(data, route, navigate, stopPlay) {
+    const r = route();
+    const test = r.view === 'test'
+        ? (data.tests.find((t) => t.report.meta.testId === r.testId) ?? null)
+        : null;
+    if (r.view !== 'test' || !test) {
+        stopPlay();
+        return;
+    }
+    const frames = testFrames(test);
+    const cur = selectedFrame(frames, r);
+    const idx = cur ? cur.index : -1;
+    const frame = frames[idx + 1];
+    if (idx < 0 || !frame) {
+        stopPlay();
+        return;
+    }
+    navigate({
+        view: 'test',
+        testId: r.testId,
+        params: { ...r.params, frame: String(frame.index + 1) },
+    }, true);
+}
+function bindWindowListeners(opts) {
+    onCleanup(opts.navigation.subscribeHash(() => {
+        opts.cancelHashWrite();
+        opts.stopPlay();
+        opts.setRoute(parseHash(opts.navigation.readHash()));
+    }));
+    onCleanup(opts.navigation.subscribeKeys((e) => onReportKeyDown(e, opts.data, {
+        toggleHelp: () => opts.setShowHelp((p) => !p),
+        showHelp: opts.showHelp,
+        showPalette: opts.showPalette,
+        togglePalette: opts.togglePalette,
+        stopPlay: opts.stopPlay,
+        navigate: (next) => opts.navigate(next),
+        goFrame: opts.goFrame,
+        togglePlay: opts.togglePlay,
+        setParam: opts.setParam,
+        route: opts.route,
+    })));
+    createEffect(() => {
+        const r = opts.route();
+        const test = r.view === 'test'
+            ? opts.data.tests.find((t) => t.report.meta.testId === r.testId)
+            : null;
+        opts.navigation.setTitle((test ? `${test.report.meta.title} · ` : '') + opts.data.title);
+    });
+}
+function makeReportNav(state) {
+    return state;
+}
+function navigateFrame(args) {
+    if (args.route.view !== 'test')
+        return;
+    const params = {
+        ...args.route.params,
+        frame: args.frame ? String(args.frame.index + 1) : '',
+    };
+    if (args.node !== undefined)
+        params['node'] = args.node || '';
+    args.navigate({ view: 'test', testId: args.route.testId, params }, true);
+}
+/**
+ * Route signal backed by the URL hash. Replace-navigation (scrub, play,
+ * toggles) updates the in-memory route at once and writes the URL on a
+ * trailing debounce: rendering never waits on history, and rapid scrubbing
+ * cannot trip replaceState rate limits.
+ */
+function createHashRoute(navigation, timers) {
+    const [route, setRoute] = createSignal(parseHash(navigation.readHash()));
+    let hashTimer = null;
+    const cancelHashWrite = () => {
+        if (hashTimer !== null)
+            timers.clearTimeout(hashTimer);
+        hashTimer = null;
+    };
+    const commitHash = () => {
+        cancelHashWrite();
+        navigation.writeHash(buildHash(route()), true);
+    };
+    const navigate = (next, replace = false) => {
+        cancelHashWrite();
+        setRoute(next);
+        if (replace)
+            hashTimer = timers.setTimeout(commitHash, 200);
+        else
+            navigation.writeHash(buildHash(next), false);
+    };
+    onCleanup(cancelHashWrite);
+    return { route, setRoute, commitHash, navigate, cancelHashWrite };
+}
+export function useReportNav(data, navigation, timers) {
+    const { route, setRoute, commitHash, navigate, cancelHashWrite } = createHashRoute(navigation, timers);
+    const [showHelp, setShowHelp] = createSignal(false);
+    const [showPalette, setShowPalette] = createSignal(false);
+    const { playing, stopPlay, togglePlay } = createPlayback(data, route, navigate, timers);
+    const goFrame = (frame, node) => navigateFrame({
+        route: route(),
+        navigate,
+        frame,
+        ...(node !== undefined ? { node } : {}),
+    });
+    const setParam = (key, value) => {
+        const r = route();
+        if (r.view !== 'test')
+            return;
+        navigate({ view: 'test', testId: r.testId, params: { ...r.params, [key]: value } }, true);
+    };
+    const stepFrame = (delta) => {
+        const r = route();
+        if (r.view !== 'test')
+            return;
+        const test = data.tests.find((t) => t.report.meta.testId === r.testId) ?? null;
+        if (!test)
+            return;
+        const frames = testFrames(test);
+        const sel = selectedFrame(frames, r);
+        const next = (sel ? sel.index : -1) + delta;
+        if (next < 0 || next >= frames.length)
+            return;
+        goFrame(frames[next] ?? null);
+    };
+    bindWindowListeners({
+        data,
+        navigation,
+        cancelHashWrite,
+        route,
+        setRoute,
+        showHelp,
+        setShowHelp,
+        showPalette,
+        togglePalette: () => setShowPalette((open) => !open),
+        stopPlay,
+        navigate,
+        goFrame,
+        togglePlay,
+        setParam,
+    });
+    return makeReportNav({
+        route,
+        showHelp,
+        showPalette,
+        playing,
+        navigate,
+        commitHash,
+        setParam,
+        goFrame,
+        stepFrame,
+        toggleHelp: () => setShowHelp(!showHelp()),
+        closeHelp: () => setShowHelp(false),
+        togglePalette: () => setShowPalette((open) => !open),
+        closePalette: () => setShowPalette(false),
+        togglePlay,
+        stopPlay,
+    });
+}
+function createPlayback(data, route, navigate, timers) {
+    let timer = null;
+    const [playing, setPlaying] = createSignal(false);
+    const stopPlay = () => {
+        if (timer !== null)
+            timers.clearInterval(timer);
+        timer = null;
+        setPlaying(false);
+    };
+    const togglePlay = () => {
+        if (playing()) {
+            stopPlay();
+            return;
+        }
+        setPlaying(true);
+        timer = timers.setInterval(() => advancePlay(data, route, navigate, stopPlay), 700);
+    };
+    onCleanup(stopPlay);
+    return { playing, stopPlay, togglePlay };
+}

package/dist/schema/src/common.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod/v4';
+export declare const RUN_STATUSES: readonly ["passed", "failed", "flaky", "not-reached"];
+export declare const RunStatusSchema: z.ZodEnum<{
+    passed: "passed";
+    failed: "failed";
+    flaky: "flaky";
+    "not-reached": "not-reached";
+}>;
+export type RunStatus = z.infer<typeof RunStatusSchema>;
+/**
+ * Who or what sends an event: a person using the product (`user`), another system (`system`), the
+ * passage of time (`time`), or a child chart handing control back to its parent (`hand-off`).
+ * `member` is read as `user`, for specs written before the kinds were renamed.
+ */
+export declare const EVENT_KINDS: readonly ["user", "system", "time", "hand-off"];
+export declare const EventKindSchema: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+    time: "time";
+    user: "user";
+    system: "system";
+    "hand-off": "hand-off";
+}>>;
+export type EventKind = z.infer<typeof EventKindSchema>;
+export declare const CONFIDENCES: readonly ["confirmed", "assumed"];
+export declare const ConfidenceSchema: z.ZodEnum<{
+    confirmed: "confirmed";
+    assumed: "assumed";
+}>;
+export type Confidence = z.infer<typeof ConfidenceSchema>;
+export declare const ImageSchema: z.ZodObject<{
+    png: z.ZodString;
+    webp: z.ZodOptional<z.ZodString>;
+    client: z.ZodOptional<z.ZodString>;
+    also: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        png: z.ZodString;
+        webp: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        client: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Image = z.infer<typeof ImageSchema>;
+export declare const CountSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    passed: z.ZodNumber;
+    failed: z.ZodNumber;
+    flaky: z.ZodNumber;
+    notReached: z.ZodNumber;
+}, z.core.$strip>;
+export type Count = z.infer<typeof CountSchema>;
+export declare const ISSUE_SEVERITIES: readonly ["error", "warning", "info"];
+export type IssueSeverity = (typeof ISSUE_SEVERITIES)[number];
+export type DataIssue = {
+    severity: IssueSeverity;
+    file: string;
+    path: string;
+    message: string;
+};
+export declare const TRANSITION_ID_SEPARATOR = " :: ";
+export declare function transitionId(source: string, event: string): string;

package/dist/schema/src/common.js

@@ -0,0 +1,32 @@
+import { z } from 'zod/v4';
+export const RUN_STATUSES = ['passed', 'failed', 'flaky', 'not-reached'];
+export const RunStatusSchema = z.enum(RUN_STATUSES);
+/**
+ * Who or what sends an event: a person using the product (`user`), another system (`system`), the
+ * passage of time (`time`), or a child chart handing control back to its parent (`hand-off`).
+ * `member` is read as `user`, for specs written before the kinds were renamed.
+ */
+export const EVENT_KINDS = ['user', 'system', 'time', 'hand-off'];
+export const EventKindSchema = z.preprocess((value) => (value === 'member' ? 'user' : value), z.enum(EVENT_KINDS));
+export const CONFIDENCES = ['confirmed', 'assumed'];
+export const ConfidenceSchema = z.enum(CONFIDENCES);
+const ScreenSchema = z.object({
+    png: z.string().min(1),
+    webp: z.string().min(1).optional().describe('About 400 px wide, for the map; the original image is used while a thumbnail is unavailable'),
+    client: z.string().optional().describe('Which client\'s screen it is, in a multi-client run')
+});
+export const ImageSchema = ScreenSchema.extend({
+    also: z.array(ScreenSchema.partial({ webp: true })).optional().describe("The other clients' screens at the same moment")
+});
+export const CountSchema = z.object({
+    total: z.number().int().nonnegative(),
+    passed: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    flaky: z.number().int().nonnegative(),
+    notReached: z.number().int().nonnegative()
+});
+export const ISSUE_SEVERITIES = ['error', 'warning', 'info'];
+export const TRANSITION_ID_SEPARATOR = ' :: ';
+export function transitionId(source, event) {
+    return `${source}${TRANSITION_ID_SEPARATOR}${event}`;
+}

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

@@ -0,0 +1,5 @@
+export * from './common.js';
+export * from './manifest.js';
+export * from './runs-index.js';
+export * from './spec.js';
+export * from './report-sources.js';

package/dist/schema/src/index.js

@@ -0,0 +1,5 @@
+export * from './common.js';
+export * from './manifest.js';
+export * from './runs-index.js';
+export * from './spec.js';
+export * from './report-sources.js';