@crvouga/atlas 1.12.0 → 1.14.0

package/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog: @crvouga/atlas
 
-## 1.12.0 (2026-10-29)
+## 1.14.0 (2026-10-29)
+
+### Features
+
+- add a UI catalog of captured states that streams, shards and is independent of the collector ([81b2938](https://github.com/crvouga/atlas/commit/81b29388b4cb77ca8c3763aac969d23436cd18dd))
+
+## 1.13.0 (2026-10-28)
+
+### Features
+
+- add the critic contract, the atlas.critique evidence, a runner and a scoped critic role ([38fdae2](https://github.com/crvouga/atlas/commit/38fdae29e2ece1b57c246140fb0e12a16d01ec25))
+
+## 1.12.0 (2026-10-28)
 
 ### Features
 

package/dist/critics/src/contract.d.ts

@@ -0,0 +1,113 @@
+/**
+ * @module The critic contract
+ *
+ * A critic is an automated reviewer of the UI catalog: it is handed one captured UI (an image and what is known about
+ * it) and answers with a judgement. Model-based, LLM-based and classic ML or heuristic critics are the same thing
+ * here, with no kind privileged: the contract is `describe`, optionally `setup`, and `evaluate` of one image. The
+ * runner (`runCritic`) owns everything else: concurrency, retries, rate limits, budgets, caching, publishing and
+ * progress. A critic never talks to Atlas, never publishes, and never sees a credential it was not configured with.
+ *
+ * Critics are producers that publish layers. Atlas never executes one inside the server.
+ *
+ * @see docs/critics.md
+ */
+import type { Critique } from '../../schema/src/critique.js';
+/** One captured UI state of the catalog, as a critic is told about it. */
+export type CatalogEntry = {
+    /** The entry's stable identity in the catalog. */
+    readonly key: string;
+    /** What a person calls it. */
+    readonly title: string;
+    /** The route or screen it shows, when known. */
+    readonly route?: string;
+    /** The kind of UI state: `screen`, `overlay`, `loading`, `error`, `empty`, or anything else the catalog declares. */
+    readonly state: string;
+    /** The device or browser profile it was captured with, in whatever shape the catalog records it. */
+    readonly profile?: unknown;
+};
+/** An entry to judge together with the hash of the image bytes that were stored for it. */
+export type JudgeableEntry = CatalogEntry & {
+    /** SHA-256 of the exact image bytes, lowercase hex. A critique is anchored to it, and an identical image is never judged twice. */
+    readonly imageSha256: string;
+};
+/** What a critic says about itself before it runs, so a person can decide whether to run it. */
+export type CriticDescription = {
+    /** Where images are sent: a host or provider name, or `null` when they never leave the machine. A run that sends images to a third party needs explicit confirmation. */
+    readonly sendsImagesTo: string | null;
+    /** The model that judges, when there is one. Part of what makes two critiques the same. */
+    readonly model?: {
+        readonly id: string;
+        readonly provider?: string;
+    };
+    /** Everything else that decides the answer and is fixed for the run: temperature, seed, the SHA-256 of the rubric. Part of what makes two critiques the same. Never put a credential here. */
+    readonly parameters?: Readonly<Record<string, unknown>>;
+    /** Whether `setup` must run first (for example to download and verify a checkpoint). */
+    readonly needsSetup: boolean;
+};
+/** What `evaluate` is handed: the exact stored bytes, their hash, the entry and a signal that fires on timeout or cancellation. */
+export type CriticInput = {
+    /** The exact bytes that were stored. */
+    readonly image: Uint8Array;
+    /** Their SHA-256, lowercase hex. */
+    readonly imageSha256: string;
+    /** What is known about the UI. */
+    readonly entry: CatalogEntry;
+    /** Aborted when the call times out or the run is cancelled. A critic that can stop early should. */
+    readonly signal: AbortSignal;
+};
+/**
+ * What `evaluate` returns: a critique without its `schema`, `subject`, `critic`, `model` and `parameters`, which the
+ * runner fills in from the critic and the entry so they cannot disagree with what was run. A critic that has only a
+ * score returns `{ verdict: { score } }`; a richer one adds `findings`.
+ */
+export type CriticAnswer = Pick<Critique, 'verdict' | 'findings' | 'usage'>;
+/**
+ * A critic. `evaluate` judges one image and may throw: throw a `CriticError` subclass (`RateLimitedError`,
+ * `InvalidOutputError`) to say why, and the runner records the failure and retries it on the next run. It never
+ * becomes a score.
+ */
+export type Critic = {
+    /** Short and stable: `uiclip`, `vision-llm`. With the version it names the critic in every critique and, as `critic.<name>`, the producer of its layers. */
+    readonly name: string;
+    /** Of the critic's own logic. A newer version replaces an older one's critiques and is judged again. */
+    readonly version: string;
+    /** Open vocabulary: `model`, `llm`, `ml`, `heuristic`, or anything else. */
+    readonly kind?: string;
+    /** Where images go, which model, which fixed parameters, whether setup is needed. */
+    describe(): CriticDescription;
+    /** Provisions what the critic needs, such as downloading and verifying a checkpoint. Inference never downloads anything. */
+    setup?(): Promise<void>;
+    /** Judges one image. */
+    evaluate(input: CriticInput): Promise<CriticAnswer>;
+};
+/**
+ * Why a critic could not produce a verdict. `reason` is a code in an open vocabulary and is what is recorded in the
+ * critique (`failure.reason`); the message is recorded too, after credentials are redacted from it.
+ */
+export declare class CriticError extends Error {
+    readonly reason: string;
+    /** @param reason the code recorded in the critique, such as `error`, `timeout`, `rate-limited`, `invalid-output`. */
+    constructor(reason: string, message: string);
+}
+/** A provider answered that it is rate limited. `retryAfterMs` is its `Retry-After`, when it said: the runner waits at least that long before trying again. */
+export declare class RateLimitedError extends CriticError {
+    readonly retryAfterMs?: number | undefined;
+    /** @param retryAfterMs milliseconds the provider asked to wait, when it said. */
+    constructor(message: string, retryAfterMs?: number | undefined);
+}
+/** A provider answered with something that is not the structure that was asked for. The entry is recorded as failed and no score is invented. */
+export declare class InvalidOutputError extends CriticError {
+    constructor(message: string);
+}
+/**
+ * Checks a critic's shape and returns it unchanged, so a typo is found where the critic is defined and not in the middle
+ * of a run. Throws when the name is not made of lowercase letters, digits, `-` and `.`, or when the version is empty.
+ *
+ * @example
+ * export default defineCritic({
+ *   name: 'contrast', version: '1.0.0', kind: 'heuristic',
+ *   describe: () => ({ sendsImagesTo: null, needsSetup: false }),
+ *   evaluate: async ({ image }) => ({ verdict: { score: measureContrast(image), scale: '0..1, higher is better' } })
+ * });
+ */
+export declare function defineCritic<T extends Critic>(critic: T): T;

package/dist/critics/src/contract.js

@@ -0,0 +1,48 @@
+/**
+ * Why a critic could not produce a verdict. `reason` is a code in an open vocabulary and is what is recorded in the
+ * critique (`failure.reason`); the message is recorded too, after credentials are redacted from it.
+ */
+export class CriticError extends Error {
+    reason;
+    /** @param reason the code recorded in the critique, such as `error`, `timeout`, `rate-limited`, `invalid-output`. */
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = 'CriticError';
+    }
+}
+/** A provider answered that it is rate limited. `retryAfterMs` is its `Retry-After`, when it said: the runner waits at least that long before trying again. */
+export class RateLimitedError extends CriticError {
+    retryAfterMs;
+    /** @param retryAfterMs milliseconds the provider asked to wait, when it said. */
+    constructor(message, retryAfterMs) {
+        super('rate-limited', message);
+        this.retryAfterMs = retryAfterMs;
+        this.name = 'RateLimitedError';
+    }
+}
+/** A provider answered with something that is not the structure that was asked for. The entry is recorded as failed and no score is invented. */
+export class InvalidOutputError extends CriticError {
+    constructor(message) {
+        super('invalid-output', message);
+        this.name = 'InvalidOutputError';
+    }
+}
+/**
+ * Checks a critic's shape and returns it unchanged, so a typo is found where the critic is defined and not in the middle
+ * of a run. Throws when the name is not made of lowercase letters, digits, `-` and `.`, or when the version is empty.
+ *
+ * @example
+ * export default defineCritic({
+ *   name: 'contrast', version: '1.0.0', kind: 'heuristic',
+ *   describe: () => ({ sendsImagesTo: null, needsSetup: false }),
+ *   evaluate: async ({ image }) => ({ verdict: { score: measureContrast(image), scale: '0..1, higher is better' } })
+ * });
+ */
+export function defineCritic(critic) {
+    if (!/^[a-z0-9][a-z0-9.-]*$/.test(critic.name))
+        throw new Error(`Invalid critic name "${critic.name}": use lowercase letters, digits, "-" and "."`);
+    if (!critic.version)
+        throw new Error(`Critic "${critic.name}" has no version`);
+    return critic;
+}

package/dist/critics/src/credentials.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @module Credentials for bring-your-own-AI critics
+ *
+ * Configuration names a credential by reference (`env:OPENAI_API_KEY`, `file:~/.config/key`) and never contains one,
+ * so it can be committed. A credential is read at run time and never written to a layer, a log, an error message, a
+ * progress display, a cache file or JSON output: everything a run writes goes through a redactor built from the
+ * credentials the run holds. A configuration that contains a literal credential is refused with a message that names
+ * where it is and never repeats it.
+ *
+ * @see docs/critics.md#credentials
+ */
+/** A credential by reference: the environment variable that holds it, or the file that does. */
+export type CredentialRef = {
+    readonly scheme: 'env';
+    readonly name: string;
+} | {
+    readonly scheme: 'file';
+    readonly path: string;
+};
+/** The text that stands for a credential in anything written. */
+export declare const REDACTED = "[redacted]";
+/**
+ * Reads a reference such as `env:OPENAI_API_KEY` or `file:/run/secrets/key`.
+ *
+ * Returns `null` when the text is not a reference (so it may be a literal credential, which configuration must not
+ * contain).
+ *
+ * @example
+ * parseCredentialRef('env:SOME_API_KEY'); // { scheme: 'env', name: 'SOME_API_KEY' }
+ */
+export declare function parseCredentialRef(text: string): CredentialRef | null;
+/**
+ * Resolves a reference to the credential it names, at run time.
+ *
+ * Throws, naming the reference and never a value, when the text is not a reference, the variable is unset or empty, or
+ * the file cannot be read or is empty. A trailing newline in a file is not part of the credential.
+ *
+ * @param ref the reference from configuration.
+ * @param source where to read from; the defaults are the process environment and the file system. Tests pass fakes.
+ */
+export declare function resolveCredential(ref: string, source?: {
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly readFile?: (path: string) => Promise<string>;
+}): Promise<string>;
+/** A place in a configuration that holds a literal credential: where, and why it was judged one. Never the value. */
+export type LiteralCredential = {
+    readonly path: string;
+    readonly reason: string;
+};
+/**
+ * Finds literal credentials in a configuration: a string under a key named like a credential (`apiKey`, `token`,
+ * `secret`…) that is not a reference, and any string anywhere that has the shape of a provider key, token or JWT.
+ * A key whose name ends in `Ref` or `Env`, or whose value is a reference, is fine.
+ *
+ * Returns the findings in document order; the value of a finding is never included.
+ */
+export declare function findLiteralCredentials(config: unknown, path?: string): LiteralCredential[];
+/**
+ * Refuses a configuration that contains a literal credential. Throws one error that lists every place, with the reason
+ * and never the value.
+ */
+export declare function assertNoLiteralCredentials(config: unknown): void;
+/** Replaces credentials in text with {@link REDACTED}. */
+export type Redactor = (text: string) => string;
+/**
+ * Builds a redactor for the credentials a run holds. It removes each secret (and its URL-encoded and base64 forms) and
+ * anything shaped like a provider key, token or JWT. Secrets shorter than 6 characters are ignored, because replacing
+ * them would damage ordinary text and they are not credentials.
+ *
+ * @param secrets the resolved credentials of the run.
+ */
+export declare function createRedactor(secrets: readonly string[]): Redactor;

package/dist/critics/src/credentials.js

@@ -0,0 +1,136 @@
+/**
+ * @module Credentials for bring-your-own-AI critics
+ *
+ * Configuration names a credential by reference (`env:OPENAI_API_KEY`, `file:~/.config/key`) and never contains one,
+ * so it can be committed. A credential is read at run time and never written to a layer, a log, an error message, a
+ * progress display, a cache file or JSON output: everything a run writes goes through a redactor built from the
+ * credentials the run holds. A configuration that contains a literal credential is refused with a message that names
+ * where it is and never repeats it.
+ *
+ * @see docs/critics.md#credentials
+ */
+/** The text that stands for a credential in anything written. */
+export const REDACTED = '[redacted]';
+/**
+ * Reads a reference such as `env:OPENAI_API_KEY` or `file:/run/secrets/key`.
+ *
+ * Returns `null` when the text is not a reference (so it may be a literal credential, which configuration must not
+ * contain).
+ *
+ * @example
+ * parseCredentialRef('env:SOME_API_KEY'); // { scheme: 'env', name: 'SOME_API_KEY' }
+ */
+export function parseCredentialRef(text) {
+    const env = /^env:([A-Za-z_][A-Za-z0-9_]*)$/.exec(text);
+    if (env)
+        return { scheme: 'env', name: env[1] };
+    const file = /^file:(.+)$/.exec(text);
+    if (file)
+        return { scheme: 'file', path: file[1] };
+    return null;
+}
+/**
+ * Resolves a reference to the credential it names, at run time.
+ *
+ * Throws, naming the reference and never a value, when the text is not a reference, the variable is unset or empty, or
+ * the file cannot be read or is empty. A trailing newline in a file is not part of the credential.
+ *
+ * @param ref the reference from configuration.
+ * @param source where to read from; the defaults are the process environment and the file system. Tests pass fakes.
+ */
+export async function resolveCredential(ref, source = {}) {
+    const parsed = parseCredentialRef(ref);
+    if (!parsed)
+        throw new Error('A credential must be given as a reference such as env:NAME or file:PATH');
+    if (parsed.scheme === 'env') {
+        const value = (source.env ?? process.env)[parsed.name];
+        if (!value)
+            throw new Error(`The credential ${ref} is not set: export ${parsed.name}`);
+        return value;
+    }
+    let text;
+    try {
+        text = await (source.readFile ?? (async (path) => (await import('node:fs/promises')).readFile(path, 'utf8')))(parsed.path);
+    }
+    catch {
+        throw new Error(`The credential ${ref} could not be read`);
+    }
+    const value = text.replace(/\r?\n$/, '');
+    if (!value)
+        throw new Error(`The credential ${ref} is empty`);
+    return value;
+}
+/** Shapes that are credentials whatever they are called: provider keys, access tokens, bearer tokens, JWTs. */
+const LOOKS_LIKE_A_CREDENTIAL = [
+    /\b(?:sk|pk|rk)-[A-Za-z0-9_-]{16,}/,
+    /\bgh[pousr]_[A-Za-z0-9]{20,}/,
+    /\bAKIA[0-9A-Z]{16}\b/,
+    /\bxox[abpr]-[A-Za-z0-9-]{10,}/,
+    /\bAIza[0-9A-Za-z_-]{30,}/,
+    /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/,
+    /\bBearer\s+[A-Za-z0-9._~+/=-]{16,}/i
+];
+const CREDENTIAL_NAME = /(?:key|token|secret|password|passwd|credential|authorization|bearer)/i;
+/**
+ * Finds literal credentials in a configuration: a string under a key named like a credential (`apiKey`, `token`,
+ * `secret`…) that is not a reference, and any string anywhere that has the shape of a provider key, token or JWT.
+ * A key whose name ends in `Ref` or `Env`, or whose value is a reference, is fine.
+ *
+ * Returns the findings in document order; the value of a finding is never included.
+ */
+export function findLiteralCredentials(config, path = '') {
+    const found = [];
+    const walk = (value, where, key) => {
+        if (typeof value === 'string') {
+            if (parseCredentialRef(value))
+                return;
+            if (CREDENTIAL_NAME.test(key) && !/(?:ref|env)$/i.test(key) && value !== '')
+                found.push({ path: where, reason: `"${key}" holds a literal value: name the credential by reference instead (env:NAME or file:PATH)` });
+            else if (LOOKS_LIKE_A_CREDENTIAL.some(pattern => pattern.test(value)))
+                found.push({ path: where, reason: 'the value has the shape of a credential: name it by reference instead (env:NAME or file:PATH)' });
+        }
+        else if (Array.isArray(value))
+            value.forEach((item, index) => walk(item, `${where}[${index}]`, key));
+        else if (value !== null && typeof value === 'object')
+            for (const [name, item] of Object.entries(value))
+                walk(item, where ? `${where}.${name}` : name, name);
+    };
+    walk(config, path, '');
+    return found;
+}
+/**
+ * Refuses a configuration that contains a literal credential. Throws one error that lists every place, with the reason
+ * and never the value.
+ */
+export function assertNoLiteralCredentials(config) {
+    const found = findLiteralCredentials(config);
+    if (found.length)
+        throw new Error(`The configuration contains ${found.length === 1 ? 'a literal credential' : 'literal credentials'}, which must never be committed or written:\n${found.map(item => `  ${item.path || '(root)'}: ${item.reason}`).join('\n')}`);
+}
+/**
+ * Builds a redactor for the credentials a run holds. It removes each secret (and its URL-encoded and base64 forms) and
+ * anything shaped like a provider key, token or JWT. Secrets shorter than 6 characters are ignored, because replacing
+ * them would damage ordinary text and they are not credentials.
+ *
+ * @param secrets the resolved credentials of the run.
+ */
+export function createRedactor(secrets) {
+    const forms = new Set();
+    for (const secret of secrets) {
+        if (secret.length < 6)
+            continue;
+        forms.add(secret);
+        forms.add(encodeURIComponent(secret));
+        forms.add(Buffer.from(secret).toString('base64'));
+    }
+    // Longest first, so a secret that contains another is removed whole.
+    const ordered = [...forms].sort((a, b) => b.length - a.length);
+    return text => {
+        let out = text;
+        for (const form of ordered)
+            out = out.split(form).join(REDACTED);
+        for (const pattern of LOOKS_LIKE_A_CREDENTIAL)
+            out = out.replace(new RegExp(pattern.source, `${pattern.flags.replace('g', '')}g`), REDACTED);
+        return out;
+    };
+}

package/dist/critics/src/critique.d.ts

@@ -0,0 +1,128 @@
+/**
+ * @module Critiques as layers
+ *
+ * Turns a critic's judgements into the checks of a layer (`critiqueChecks`, `critiqueLayer`) and reads them back
+ * (`readCritique`, `critiquesOfLayer`). A critique is a check in a part of kind `critique` whose `status` says whether
+ * the critic ran; the opinion is in `extensions["atlas.critique"]`, and is repeated in standard evidence (a
+ * measurement for the score, an annotation for each finding) so a viewer that has never heard of critics still shows
+ * it. Critiques are anchored to the image hash they judged: when an entry's image changes, an older critique is still
+ * shown, as judging an earlier image, and the entry counts as not yet judged (`critiqueCurrency`).
+ *
+ * @see docs/critics.md
+ * @see docs/extending.md
+ */
+import { type Critique } from '../../schema/src/critique.js';
+import type { PublishChecksInput } from '../../schema/src/layer.js';
+import type { Critic, CriticDescription, JudgeableEntry } from './contract.js';
+/** The prefix of the id of every critique check: `critique/<entry key>`. It keeps a critique from ever sharing a slot with a test. */
+export declare const CRITIQUE_CHECK_PREFIX = "critique/";
+/** The result of judging one entry: a critique, or the reason there is none. Either way it has what it judged. */
+export type CritiqueOutcome = {
+    /** The entry and the image that was judged. */
+    readonly entry: JudgeableEntry;
+    /** The critique with its subject, critic and verdict (or failure) filled in. */
+    readonly critique: Critique;
+};
+/** The check ids and labels one critique is published under. */
+export declare function critiqueCheckId(entryKey: string): string;
+/** `critic.<name>`: the producer of every layer of the critic's critiques. A critic-scoped token may publish only such layers. */
+export declare function criticProducer(criticName: string): string;
+/**
+ * Builds the critique a critic produced for an entry. It fills in `schema`, `subject`, `critic`, `model` and
+ * `parameters` from the critic and the entry (so they cannot disagree with what was run) and keeps the verdict,
+ * findings and usage as given.
+ *
+ * @param critic the critic that ran.
+ * @param description the critic's `describe()` at the time of the run.
+ * @param entry the entry and the image hash that was judged.
+ * @param answer the critic's answer, or a `failure` instead of one.
+ */
+export declare function buildCritique(critic: Pick<Critic, 'name' | 'version' | 'kind'>, description: CriticDescription, entry: JudgeableEntry, answer: Pick<Critique, 'verdict' | 'findings' | 'usage' | 'failure'>): Critique;
+/**
+ * The checks of one layer for a set of outcomes, in the order given. A verdict is a `passed` check (the critic ran), a
+ * failure a `failed` one with its reason code in `detail`. The score is a measurement named `polish`; each finding is
+ * also an annotation of type `critique`. Nothing here decides a result: a low score is `passed`.
+ */
+export declare function critiqueChecks(outcomes: readonly CritiqueOutcome[], options?: {
+    readonly threshold?: number;
+}): NonNullable<PublishChecksInput['checks']>;
+/**
+ * The input of `publishChecks` for one critic's outcomes: producer `critic.<name>`, part kind `critique`. The model and
+ * critic versions are labels and not part of the slot, so a newer version replaces an older one's critique of the same
+ * entry. Pass `parameters` to move something (such as a model version) into the slot instead, to compare side by side.
+ *
+ * @param args.critic the critic that ran.
+ * @param args.outcomes what it produced, successes and failures.
+ * @param args.recordedAtMs when, epoch milliseconds. Nothing here reads a clock, so the same input is the same layer.
+ */
+export declare function critiqueLayer(args: {
+    readonly critic: Pick<Critic, 'name' | 'version'>;
+    readonly outcomes: readonly CritiqueOutcome[];
+    readonly recordedAtMs: number;
+    readonly sha?: string | null;
+    readonly branch?: string | null;
+    readonly runUrl?: string | null;
+    readonly environment?: string | null;
+    readonly parameters?: Readonly<Record<string, string>>;
+    readonly threshold?: number;
+}): PublishChecksInput;
+/**
+ * Reads the critique of a check, or `null` when there is none that this reader can read: no `atlas.critique` extension,
+ * one that is malformed (a missing `subject`, a score that is not a number), or one of a version this release does not
+ * know. The check and its status are never affected: an unreadable opinion is unknown, not a pass and not a failure.
+ * Fields and values it does not know (a new category, severity or label) are kept.
+ */
+export declare function readCritique(check: {
+    readonly extensions?: Readonly<Record<string, unknown>> | undefined;
+}): Critique | null;
+/** A critique found in a layer, with where it was found and whether the critic ran. */
+export type FoundCritique = {
+    readonly layerId: string;
+    readonly producer: string;
+    readonly recordedAtMs: number;
+    readonly checkId: string;
+    /** The check's own status: whether the critic ran, never what it thought. */
+    readonly status: string;
+    readonly critique: Critique;
+};
+/**
+ * Every readable critique in a layer's parts of kind `critique`. Checks whose critique cannot be read are left out, and
+ * so is any `atlas.critique` extension in a part of another kind: a test result is never mistaken for an opinion.
+ */
+export declare function critiquesOfLayer(layer: {
+    readonly id: string;
+    readonly producer: string;
+    readonly parts: readonly {
+        readonly kind: string;
+        readonly recordedAtMs: number;
+        readonly checks: readonly {
+            readonly id: string;
+            readonly status: string;
+            readonly extensions?: Readonly<Record<string, unknown>> | undefined;
+        }[];
+    }[];
+}): FoundCritique[];
+/**
+ * Whether a critique judged the image an entry has now. `current`: yes. `earlier-image`: the entry's image has changed
+ * since, so the critique is shown as judging an earlier image and the entry counts as not yet judged by that critic.
+ */
+export declare function critiqueCurrency(critique: Pick<Critique, 'subject'>, currentImageSha256: string): 'current' | 'earlier-image';
+/**
+ * The identity of a critique for caching: the critic, its version, the model, the fixed parameters (the rubric hash
+ * among them) and the image hash. Two critiques with the same identity are the same judgement, and the second is not
+ * made. Key order in `parameters` does not matter.
+ */
+export declare function critiqueIdentity(args: {
+    readonly critic: {
+        readonly name: string;
+        readonly version: string;
+    };
+    readonly model?: {
+        readonly id: string;
+        readonly provider?: string | undefined;
+    } | undefined;
+    readonly parameters?: Readonly<Record<string, unknown>> | undefined;
+    readonly imageSha256: string;
+}): string;
+/** The identity of an existing critique, as {@link critiqueIdentity} computes it for a run. */
+export declare function identityOfCritique(critique: Critique): string;