@calliopelabs/ui 0.6.1 → 0.11.0

package/dist/provider/messages.js

@@ -1,5 +1,148 @@
 const lower = (label) => label.toLocaleLowerCase("en");
 const count = (n) => n.toLocaleString("en");
+/** "a", "a or b", "a, b or c". */
+const either = (items) => items.length <= 1 ? items.join("") : `${items.slice(0, -1).join(", ")} or ${items.at(-1)}`;
+const KIND_LABEL = {
+    step: "Step",
+    subflow: "Sub-flow",
+    gate: "Gate",
+    condition: "Condition",
+    goto: "Go to",
+    fanout: "Fan out",
+    join: "Join",
+    variants: "Variants",
+    evaluator: "Evaluator",
+    classifier: "Classifier",
+    check: "Yes or no",
+};
+const KIND_HINT = {
+    step: "One unit of work, from a module's preset or your own",
+    subflow: "Runs another flow of this workflow in its place",
+    gate: "Waits until people, a score, a policy or a time window say go",
+    condition: "If or switch on run facts; each case is its own exit",
+    goto: "Jumps back to a named node, at most a set number of times",
+    fanout: "Starts every branch leaving it",
+    join: "Waits for all, any or some of the branches arriving",
+    variants: "Runs one step several ways side by side and keeps a winner",
+    evaluator: "Scores its subject on a rubric and routes on pass or fail",
+    classifier: "Labels its subject and routes on the label",
+    check: "Asks a yes or no question and routes on the answer",
+};
+const EXIT_NAME = {
+    else: "else",
+    yes: "yes",
+    no: "no",
+    other: "other",
+    pass: "pass",
+    fail: "fail",
+    out: "next",
+};
+const exitName = (exit) => EXIT_NAME[exit] ?? exit;
+function problemText({ code, values: v }) {
+    const n = `"${v.node}"`;
+    switch (code) {
+        case "no-main":
+            return `The main flow "${v.flow}" is missing.`;
+        case "flow-empty":
+            return `${v.flow} has no nodes yet.`;
+        case "duplicate-id":
+            return `The node id "${v.id}" is used twice.`;
+        case "unreachable":
+            return `${n} can never be reached.`;
+        case "dangling-edge":
+            return `A connection from ${v.from} to ${v.to} points at a node that is not here.`;
+        case "missing-exit":
+            return `"${v.from}" has no ${exitName(String(v.exit))} exit.`;
+        case "cycle":
+            return `${v.flow} goes round in a circle that never ends. Go back with a loop instead.`;
+        case "loop-no-until":
+            return `The loop from "${v.from}" back to "${v.to}" has no exit condition.`;
+        case "loop-no-max":
+            return `The loop from "${v.from}" back to "${v.to}" has no limit.`;
+        case "loop-not-back":
+            return `The loop from "${v.from}" does not go back to an earlier node.`;
+        case "exit-unwired":
+            return `The ${exitName(String(v.exit))} exit of ${n} goes nowhere; a run that takes it stops there.`;
+        case "input-unbound":
+            return `${n} needs ${v.input} (${v.type}), and nothing before it makes one.`;
+        case "data-port-missing":
+            return `A data connection from "${v.from}" to "${v.to}" names a port that is not there.`;
+        case "data-type":
+            return `${v.output} of "${v.from}" (${v.given}) does not fit ${v.input} of "${v.to}" (${v.wanted}).`;
+        case "data-order":
+            return `"${v.to}" takes ${v.output} from "${v.from}", which does not run before it.`;
+        case "unknown-preset":
+            return `${n} uses ${v.module}/${v.preset}, which this factory's modules do not offer.`;
+        case "unknown-model":
+            return `${n} names the model "${v.value}", which is not offered here.`;
+        case "unknown-harness":
+            return `${n} names the harness "${v.value}", which is not offered here.`;
+        case "unknown-effort":
+            return `${n} names the effort "${v.value}", which is not offered here.`;
+        case "subflow-none":
+            return `${n} names no flow to run.`;
+        case "subflow-missing":
+            return `${n} calls the flow "${v.flow}", which does not exist.`;
+        case "subflow-recursive":
+            return `${n} calls "${v.flow}", which calls back into this flow.`;
+        case "unknown-gate-kind":
+            return `${n} is a "${v.gate}" gate, which this factory does not know.`;
+        case "gate-no-approver":
+            return `${n} has no role or member to approve.`;
+        case "gate-quorum":
+            return `${n} needs ${v.quorum} approvals from ${v.members} named members.`;
+        case "gate-no-threshold":
+            return `${n} has no threshold.`;
+        case "gate-no-rule":
+            return `${n} has no rule.`;
+        case "gate-no-timeout-action":
+            return `${n} times out but does not say what happens then.`;
+        case "no-cases":
+            return `${n} has no cases.`;
+        case "unknown-fact":
+            return `${n} tests "${v.fact}", which this factory's runs do not report.`;
+        case "unknown-operator":
+            return `${n} compares with "${v.op}", which this factory does not know.`;
+        case "operator-mismatch":
+            return `${n} uses "${v.op}", which does not fit ${v.fact}.`;
+        case "value-missing":
+            return `${n} compares ${v.fact} with nothing.`;
+        case "value-type":
+            return `${n} compares ${v.fact} with a value of the wrong kind.`;
+        case "fact-node-missing":
+            return `${n} tests ${v.fact} but names no node it can come from.`;
+        case "goto-no-target":
+            return `${n} has no target.`;
+        case "goto-missing-target":
+            return `${n} jumps to "${v.target}", which is not in this flow.`;
+        case "goto-no-max":
+            return `${n} has no limit, so it could jump forever.`;
+        case "fanout-few":
+            return `${n} has fewer than two branches.`;
+        case "join-few":
+            return `${n} has fewer than two branches arriving.`;
+        case "join-no-n":
+            return `${n} waits for some branches but does not say how many.`;
+        case "variants-few":
+            return `${n} needs at least two variants.`;
+        case "variants-no-select":
+            return `${n} does not say how the winner is picked.`;
+        case "variants-no-evaluator":
+            return `${n} picks by evaluator score but names no evaluator.`;
+        case "rubric-short":
+            return `${n} needs a rubric of at least two levels.`;
+        case "no-threshold":
+            return `${n} routes on pass and fail but has no threshold.`;
+        case "no-question":
+            return `${n} asks no question.`;
+        case "options-few":
+            return `${n} needs at least two labels.`;
+        case "option-duplicate":
+            return `${n} has the label "${v.option}" twice.`;
+        case "not-runnable":
+            return `${n} cannot run here.`;
+    }
+}
 export const defaultMessages = {
     shell: {
         skipToContent: "Skip to content",
@@ -12,6 +155,8 @@ export const defaultMessages = {
         expand: "Expand sidebar",
         collapseTitle: "Collapse sidebar ([)",
         expandTitle: "Expand sidebar ([)",
+        withBadge: (label, badge) => `${label}, ${badge}`,
+        areaWithBadges: (area) => `${area}, has updates`,
     },
     rail: {
         show: (label) => `Show ${lower(label)}`,
@@ -65,6 +210,19 @@ export const defaultMessages = {
         failed: "That did not work. Try again.",
         reasonRequired: "A reason is required.",
     },
+    data: {
+        noValue: "No data",
+        notSet: "Not set",
+        removeTag: (label) => `Remove ${label}`,
+    },
+    avatar: {
+        people: (names, more) => {
+            const all = more > 0 ? [...names, `${count(more)} more`] : [...names];
+            if (all.length <= 1)
+                return all.join("");
+            return `${all.slice(0, -1).join(", ")} and ${all[all.length - 1]}`;
+        },
+    },
     user: {
         accountMenu: (name, initials) => `${initials}, account menu for ${name}`,
         signOut: "Sign out",
@@ -95,6 +253,481 @@ export const defaultMessages = {
         customAccentOk: (ratio) => `${ratio}:1 against this ground.`,
         customAccentFaint: (ratio, min, mode) => `${ratio}:1 against this ground; it needs ${min}:1. Try a ${mode === "dark" ? "lighter" : "darker"} colour.`,
     },
+    workflow: {
+        status: (status) => (status === "draft" ? "Draft" : "Published"),
+        scope: (scope) => ({ private: "Private", project: "Project", organization: "Organization", shared: "Shared" })[scope],
+        module: (label, version) => (version ? `${label} ${version}` : label),
+        revision: (revision) => `Revision ${revision}`,
+        action: (action) => ({ edit: "Edit", start: "Start", export: "Export" })[action],
+        actionName: (label, name) => `${label} ${name}`,
+        availability: (status) => ({
+            available: "Available",
+            unsupported: "Unavailable",
+            "missing-capabilities": "Missing capabilities",
+        })[status],
+        unsupported: "This factory does not have this module, so the workflow cannot start here.",
+        missingCapabilities: (missing) => missing.length
+            ? `Cannot start here: missing ${missing.join(", ")}.`
+            : "Cannot start here: a capability it needs is missing.",
+        denied: (actions) => `Your role cannot ${either(actions.map(lower))} this workflow.`,
+        preview: (name) => `Preview of ${name}`,
+        galleryTitle: "Workflows",
+        filters: "Find workflows",
+        search: "Search workflows",
+        moduleFilter: "Module",
+        anyModule: "All modules",
+        scopeFilter: "Scope",
+        anyScope: "Any scope",
+        statusFilter: "Status",
+        anyStatus: "Any status",
+        view: "View",
+        grid: "Grid",
+        list: "List",
+        count: (n) => (n === 1 ? "1 workflow" : `${count(n)} workflows`),
+        create: "New workflow",
+        import: "Import",
+        loadFailed: "Could not load workflows",
+        empty: "No workflows yet",
+        emptyDescription: "Save a workflow to reuse it here, or import one from another factory.",
+        noMatches: "No matches",
+        noMatchesDescription: "No workflows match the search and filters.",
+        clearFilters: "Clear filters",
+    },
+    editor: {
+        kind: (kind) => KIND_LABEL[kind],
+        kindHint: (kind) => KIND_HINT[kind],
+        exit: (exit) => exitName(exit),
+        selector: (selector) => ({
+            evaluator: "Highest evaluator score",
+            "first-passing": "First that passes",
+            "cheapest-passing": "Cheapest that passes",
+            person: "A person picks",
+        })[selector],
+        problemLevel: (level) => ({ blocking: "Blocking", warning: "Warning", "not-run": "Not run here" })[level],
+        problem: (p) => problemText(p),
+        connect: (reason, v) => ({
+            "missing-node": "Both ends must be nodes in this flow.",
+            self: "A node cannot connect to itself.",
+            "loop-target": "A loop goes into a node's loop input.",
+            "loop-not-back": `A loop goes back to a node before ${v.from}.`,
+            "loop-exists": `${v.from} already loops back to ${v.to}.`,
+            "next-target": "The run goes on into a node's input.",
+            "no-exit": `${v.from} has no ${exitName(v.exit ?? "")} exit.`,
+            "exit-taken": `The ${exitName(v.exit ?? "")} exit of ${v.from} already goes somewhere. Use a fan-out for branches.`,
+            exists: `${v.from} already goes to ${v.to}.`,
+            cycle: "That would make a cycle. Go back with a loop instead.",
+            "no-output": `${v.from} has no such output.`,
+            "no-input": `${v.to} has no such input.`,
+            "data-target": "An output goes into an input.",
+            "type-mismatch": `${v.output} (${v.given}) does not fit ${v.input} (${v.wanted}).`,
+            "data-order": `${v.to} does not run after ${v.from}, so it cannot take its ${v.output}.`,
+            "input-taken": `${v.input} of ${v.to} already has a source.`,
+        })[reason],
+        readError: (e) => e.code === "not-json"
+            ? "This is not valid JSON."
+            : e.code === "not-a-package"
+                ? "This is not a workflow package."
+                : e.code === "unsupported-version"
+                    ? `This was written in format version ${String(e.version)}, which this editor cannot read.`
+                    : `This is not a workflow definition: ${e.path} is missing or wrong.`,
+        canvas: "Workflow canvas",
+        canvasTools: "Canvas tools",
+        add: "Add",
+        paletteGroup: (group) => ({ gates: "Gates", logic: "Logic", judges: "Judges", other: "Other" })[group],
+        customStep: "Custom step",
+        connectAction: "Connect",
+        connectTitle: (node) => `Connect ${node}`,
+        connectDescription: "Pick an exit, a loop or an output, then where it goes. Only connections that fit are offered.",
+        connectFrom: "From",
+        connectTo: "To",
+        connectNone: "Nothing in this flow can take a connection from here.",
+        cancel: "Cancel",
+        deleteSelection: "Delete",
+        arrange: "Arrange",
+        zoomIn: "Zoom in",
+        zoomOut: "Zoom out",
+        fit: "Fit to view",
+        nodeName: (kind, label, blocking, warnings, notRun) => [
+            `${kind}: ${label}`,
+            blocking
+                ? blocking === 1
+                    ? "1 blocking problem"
+                    : `${count(blocking)} blocking problems`
+                : "",
+            warnings ? (warnings === 1 ? "1 warning" : `${count(warnings)} warnings`) : "",
+            notRun ? "not run here" : "",
+        ]
+            .filter(Boolean)
+            .join(", "),
+        edgeName: (kind, from, to, detail) => ({
+            next: `${from} to ${to}`,
+            loop: `Loop from ${from} back to ${to}`,
+            data: `Data from ${from} to ${to}`,
+            goto: `${from} jumps to ${to}`,
+        })[kind] + (detail ? `, ${detail}` : ""),
+        summary: (n, names) => {
+            switch (n.kind) {
+                case "step":
+                    return names.preset ? `${names.module} · ${names.preset}` : "Custom step";
+                case "subflow":
+                    return n.flow ? `Runs ${n.flow}${n.each ? `, once per ${n.each}` : ""}` : "Names no flow";
+                case "gate":
+                    return names.gate ?? n.gate;
+                case "condition":
+                    return n.cases.length === 1 ? "If, else" : `${count(n.cases.length)} cases, else`;
+                case "goto":
+                    return names.target ? `To ${names.target}, at most ${n.max ?? "?"}` : "No target";
+                case "fanout":
+                    return "Every branch";
+                case "join":
+                    return n.wait === "n"
+                        ? `Waits for ${n.n ?? "?"}`
+                        : n.wait === "all"
+                            ? "Waits for all"
+                            : "Waits for any";
+                case "variants":
+                    return `${count(n.variants.length)} variants`;
+                case "evaluator":
+                    return n.routes && n.threshold !== undefined
+                        ? `Passes at ${Math.round(n.threshold * 100)}%`
+                        : `${count(n.levels.length)} levels`;
+                case "classifier":
+                    return n.options.length === 1 ? "1 label" : `${count(n.options.length)} labels`;
+                case "check":
+                    return n.question || "No question";
+            }
+        },
+        notRun: "Not run here",
+        loopMax: (max) => (max ? `at most ${count(max)}` : "no limit"),
+        port: (label, type) => `${label} (${type})`,
+        loopHandle: "Loop back",
+        loopInHandle: "Loop in",
+        inHandle: "In",
+        regionName: (kind, head, n) => kind === "loop"
+            ? `Loop from ${head}, ${count(n)} nodes`
+            : `Branches from ${head}, ${count(n)} nodes`,
+        fold: (name) => `Fold ${name}`,
+        unfold: (name) => `Unfold ${name}`,
+        showInPlace: (label) => `Show ${label} in place`,
+        hideInPlace: (label) => `Fold ${label}`,
+        readOnly: "Read only",
+        connected: (from, to) => `Connected ${from} to ${to}.`,
+        added: (label) => `Added ${label}.`,
+        deleted: (n) => (n === 1 ? "Deleted 1 item." : `Deleted ${count(n)} items.`),
+        selected: (name) => `Selected ${name}.`,
+        nodeHelp: "Press Enter or Space to select. Arrow keys move a selected node, Shift with an arrow moves it further. Delete removes it.",
+        edgeHelp: "Press Enter or Space to select. Delete removes it.",
+        movedLive: (direction, x, y) => `Moved ${direction}, to ${Math.round(x)}, ${Math.round(y)}.`,
+        palette: "Add to the flow",
+        paletteSearch: "Find a step, gate or block",
+        paletteEmpty: "Nothing matches.",
+        problems: "Problems",
+        noProblems: "Nothing blocks publishing",
+        problemCount: (level, n) => level === "blocking"
+            ? n === 1
+                ? "1 blocking"
+                : `${count(n)} blocking`
+            : level === "warning"
+                ? n === 1
+                    ? "1 warning"
+                    : `${count(n)} warnings`
+                : n === 1
+                    ? "1 node not run here"
+                    : `${count(n)} nodes not run here`,
+        json: "Definition as JSON",
+        jsonHint: "Edits here apply as soon as the text reads as a definition.",
+        inspector: "Properties",
+        inspectorFor: (kind, label) => `${kind}: ${label}`,
+        inspectorEmpty: "Select a node or a connection to edit it.",
+        workflowDetails: "Workflow",
+        name: "Name",
+        description: "Description",
+        runInputs: "What a run starts with",
+        label: "Label",
+        nodeId: (id) => `Id: ${id}`,
+        note: "Note",
+        choose: "Choose",
+        hostDefault: "Default",
+        preset: "Preset",
+        noPreset: "No preset",
+        model: "Model",
+        harness: "Harness",
+        effort: "Effort",
+        inputs: "Inputs",
+        outputs: "Outputs",
+        optional: "optional",
+        addPort: "Add a port",
+        newPort: "New port",
+        portLabel: "Port name",
+        portType: "Type",
+        anyType: "Anything",
+        remove: (label) => `Remove ${label}`,
+        subflow: "Flow to run",
+        each: "Once per",
+        eachHint: "Runs the flow once for each item of this input. Leave it empty to run it once.",
+        gateKind: "Kind of gate",
+        approvers: "Approval",
+        roles: "Roles",
+        members: "Named members",
+        quorum: "Approvals needed",
+        quorumHint: "One when empty.",
+        timeoutHours: "Timeout in hours",
+        onTimeout: "When it times out",
+        onTimeoutOption: (option) => (option === "fail" ? "Fail the run" : "Escalate"),
+        threshold: "Pass at (%)",
+        rule: "Rule",
+        cases: "Cases",
+        caseLabel: "Case name",
+        addCase: "Add a case",
+        newCase: (n) => `Case ${count(n)}`,
+        when: (label) => `${label}: when`,
+        fact: "Run fact",
+        factNode: "Of node",
+        operator: "Comparison",
+        value: "Value",
+        boolean: (value) => (value ? "Yes" : "No"),
+        target: "Jump to",
+        limit: "At most (times)",
+        wait: "Waits for",
+        waitOption: (wait) => ({ all: "All branches", any: "Any branch", n: "Some branches" })[wait],
+        waitN: "How many",
+        winner: "Winner",
+        evaluator: "Evaluator that picks",
+        variants: "Variants",
+        addVariant: "Add a variant",
+        newVariant: (n) => `Variant ${count(n)}`,
+        variantLabel: "Variant name",
+        question: "Question",
+        levels: "Rubric",
+        levelsHint: "One level per line, lowest first.",
+        routes: "Route on pass and fail",
+        minConfidence: "Ask a person below (%)",
+        minConfidenceHint: "Below this confidence a person decides.",
+        options: "Labels",
+        addOption: "Add a label",
+        newOption: (n) => `Label ${count(n)}`,
+        optionLabel: "Label",
+        optionDescription: "What it means",
+        otherExit: "Other exit, for inputs no label fits",
+        yesAt: "Yes at (%)",
+        exitIs: (exit) => `Leaves by the ${exit} exit.`,
+        edgeLabel: "Label",
+        dataFlow: (output, input) => `Hands ${output} to ${input}.`,
+        until: "Until",
+        deleteNode: (label) => `Delete ${label}`,
+        deleteEdge: "Delete this connection",
+    },
+    workspace: {
+        loading: "Loading the workflow",
+        loadFailed: "Could not load the workflow",
+        actions: "Workflow actions",
+        panels: "Panels",
+        paletteRegion: "Building blocks",
+        problemsTab: (n) => (n ? `Problems (${count(n)})` : "Problems"),
+        jsonTab: "JSON",
+        flow: "Flow",
+        unsaved: "Unsaved changes",
+        saved: (label) => (label ? `Saved, revision ${label}` : "Saved"),
+        live: (label) => (label ? `Live, revision ${label}` : "Live"),
+        differsFromLive: (label) => label ? `Differs from live revision ${label}` : "Differs from live",
+        notPublished: "Not published",
+        conflict: "Conflict",
+        conflictDescription: (by, label) => `${by ? `${by} saved` : "Someone saved"} ${label ? `revision ${label}` : "a newer revision"} while you had unsaved changes. Compare them, use theirs, or keep yours and save over it.`,
+        compare: "Compare",
+        compareTitle: "Your changes against the saved revision",
+        compareDescription: "What saving your copy would change in the revision saved since you started.",
+        useTheirs: "Use theirs",
+        keepMine: "Keep mine",
+        save: "Save draft",
+        saving: "Saving",
+        savedNotice: "Draft saved.",
+        saveAs: "Save as",
+        saveAsTitle: "Save as a new workflow",
+        saveAsDescription: "A copy under its own name, to reuse. This workflow stays as it is.",
+        copyName: (name) => `${name} (copy)`,
+        savedAsNotice: (name) => `Saved as ${name}.`,
+        publish: "Publish",
+        publishing: "Publishing",
+        publishTitle: "Publish this draft?",
+        publishDescription: (label) => `It replaces what runs today${label ? `, revision ${label}` : ""}. New runs use it; runs in progress keep theirs.`,
+        firstPublish: "This is its first publish. New runs use it.",
+        draftAgainstLive: "Draft against live",
+        publishBlocked: (n) => n === 1
+            ? "1 blocking problem must be fixed first."
+            : `${count(n)} blocking problems must be fixed first.`,
+        publishedNotice: "Published.",
+        failed: "That did not work. Try again.",
+        discard: "Discard changes",
+        discardTitle: "Discard your changes?",
+        discardDescription: "Your copy goes back to the revision you started from. Unsaved changes are lost.",
+        export: "Export",
+        import: "Import",
+        importTitle: "Import a workflow package",
+        importDescription: "What importing it would do here. Nothing changes until you import.",
+        importAction: "Import",
+        importing: "Importing",
+        importedNotice: "Imported.",
+        importAvailability: (status) => ({
+            available: "Runs here",
+            "missing-capabilities": "Missing capabilities here",
+            unsupported: "Cannot run here",
+        })[status],
+        modules: "Modules",
+        noModules: "It needs no module.",
+        moduleStatus: (status, installed) => ({
+            available: "Installed",
+            missing: "Not installed here",
+            version: `Installed at ${installed ?? "another version"}`,
+            unavailable: "Installed, not available",
+        })[status],
+        missingCapabilities: "Missing capabilities",
+        unknownVocabulary: "Not known here",
+        unknownGateKind: (id) => `Gate kind "${id}"`,
+        unknownFact: (id) => `Run fact "${id}"`,
+        unknownOperator: (id) => `Comparison "${id}"`,
+        disabledNodes: (n) => n === 1 ? "1 node would be disabled" : `${count(n)} nodes would be disabled`,
+        needsApprovers: "Gates that need approvers here",
+        importBlocking: (n) => n === 1 ? "1 blocking problem here." : `${count(n)} blocking problems here.`,
+        replaces: "Against the workflow it replaces",
+        diff: "Changes",
+        noChanges: "Nothing that runs changes.",
+        onlyMoved: (n) => n === 1
+            ? "Only 1 node moved; nothing that runs changes."
+            : `Only ${count(n)} nodes moved; nothing that runs changes.`,
+        moved: (n) => (n === 1 ? "1 node moved." : `${count(n)} nodes moved.`),
+        change: (change, what) => `${what} ${change}`,
+        details: "Details",
+        detail: (key) => ({ name: "name", description: "description", module: "module", main: "main flow" })[key],
+        flows: "Flows",
+        nodes: "Nodes",
+        connections: "Connections",
+    },
+    run: {
+        timeline: "Run stages",
+        loadFailed: (label) => `Could not load ${lower(label)}`,
+        noStages: "No stages yet",
+        noStagesDescription: "Stages appear here as the run starts them.",
+        stageStatus: (status) => ({
+            pending: "pending",
+            running: "running",
+            waiting: "waiting",
+            blocked: "blocked",
+            passed: "passed",
+            failed: "failed",
+            skipped: "skipped",
+            cancelled: "cancelled",
+        })[status],
+        attempt: (attempt, max) => max ? `Attempt ${count(attempt)} of ${count(max)}` : `Attempt ${count(attempt)}`,
+        startedAt: (time) => `Started ${time}`,
+        duration: (duration) => duration,
+        inputsOutputs: (inputs, outputs) => `${inputs === 1 ? "1 input" : `${count(inputs)} inputs`}, ${outputs === 1 ? "1 output" : `${count(outputs)} outputs`}`,
+        inputs: "Inputs",
+        outputs: "Outputs",
+        none: "None",
+        gate: (label, status, approvals, required) => {
+            const word = {
+                waiting: "waiting",
+                approved: "approved",
+                rejected: "rejected",
+                expired: "expired",
+                skipped: "skipped",
+            }[status];
+            const quorum = required ? ` (${count(approvals ?? 0)} of ${count(required)})` : "";
+            return `${label}: ${word}${quorum}`;
+        },
+        artifacts: "Artifacts",
+        noArtifacts: "No artifacts yet",
+        noArtifactsDescription: "What the run produces appears here.",
+        artifactStatus: (status) => ({
+            draft: "draft",
+            "in-review": "in review",
+            approved: "approved",
+            rejected: "rejected",
+            superseded: "superseded",
+        })[status],
+        version: (version) => `Version ${version}`,
+        producedBy: (stage) => `From ${stage}`,
+    },
+    review: {
+        title: "Review",
+        titleFor: (subject) => `Review: ${subject}`,
+        verdict: (verdict) => ({
+            pending: "pending",
+            approved: "approved",
+            "changes-requested": "changes requested",
+            rejected: "rejected",
+        })[verdict],
+        decided: (verdict, by, at) => `${verdict === "approved" ? "Approved" : "Rejected"}${by ? ` by ${by}` : ""}${at ? `, ${at}` : ""}.`,
+        approve: "Approve",
+        reject: "Reject",
+        approveTitle: "Approve this?",
+        approveDescription: "Your approval is recorded on this review with your name.",
+        rejectTitle: "Reject this?",
+        rejectDescription: "Your rejection and its reason are recorded on this review with your name.",
+        reasonLabel: "Reason",
+        comments: (n) => (n === 1 ? "1 comment" : `${count(n)} comments`),
+        noComments: "No comments yet.",
+        addComment: "Add a comment",
+        post: "Comment",
+        commentOn: (anchor) => `Commenting on ${anchor}`,
+        clearAnchor: "Comment on the whole",
+        goToAnchor: (anchor) => `${anchor}, go to it`,
+        resolved: "resolved",
+    },
+    media: {
+        markers: "Comments on the timeline",
+        timeComment: (timecode, author) => `${timecode}, comment by ${author}`,
+        regionComment: (author, timecode) => timecode ? `Region at ${timecode}, comment by ${author}` : `Region, comment by ${author}`,
+        commentHere: "Comment here",
+        drawHint: "Drag on the image to comment on a region.",
+        count: (n) => (n === 1 ? "1 comment" : `${count(n)} comments`),
+        markRegion: "Mark a region",
+        regionBox: "Region to comment on",
+        regionHelp: "Arrow keys move the region, Shift and arrow keys resize it, Enter comments on it, Escape cancels.",
+        regionBounds: (left, top, width, height) => `${left}% from the left, ${top}% from the top, ${width}% wide, ${height}% high`,
+        confirmRegion: "Comment on region",
+        cancel: "Cancel",
+    },
+    document: {
+        changes: (n) => (n === 1 ? "1 change" : `${count(n)} changes`),
+        annotations: (n) => (n === 1 ? "1 annotation" : `${count(n)} annotations`),
+        pages: "Pages",
+        previousPage: "Previous page",
+        nextPage: "Next page",
+        pageOf: (page, total) => `Page ${count(page)} of ${count(total)}`,
+        anchor: (page, clause) => (clause ? `p. ${page}, ${clause}` : `p. ${page}`),
+        commentOnClause: (clause) => `${clause}, comment on this clause`,
+        commentOnBlock: (anchor) => `Comment on this paragraph, ${anchor}`,
+        inserted: (text) => `inserted: ${text}`,
+        deleted: (text) => `deleted: ${text}`,
+        annotationBy: (author, anchor) => `Annotation by ${author}, ${anchor}`,
+        empty: "This page has no text.",
+        signOff: "Sign-off",
+        signOffAction: "Sign off",
+        signOffStatus: (status) => ({ pending: "pending", signed: "signed", declined: "declined" })[status],
+        signOffTitle: (title) => `Sign off ${title}?`,
+        signOffDescription: (role) => role
+            ? `You sign as ${role}. Your name and the time are recorded.`
+            : "Your name and the time are recorded.",
+    },
+    form: {
+        source: "Source",
+        sourcePage: "Source page",
+        page: (page) => `Page ${count(page)}`,
+        fields: "Extracted fields",
+        fieldOnSource: (label) => `${label}, on the source page`,
+        progress: (done, total, flagged) => `${count(done)} of ${count(total)} confirmed${flagged ? `, ${count(flagged)} flagged` : ""}`,
+        confidence: (confidence) => `${Math.round(confidence * 100)}% confident`,
+        status: (status) => (status === "accepted" ? "accepted" : "corrected"),
+        accept: "Accept",
+        correct: "Correct",
+        actionName: (label, field) => `${label} ${field}`,
+        correctLabel: (label) => `Corrected ${label}`,
+        extracted: (value) => `Extracted: ${value}`,
+        save: "Save",
+        cancel: "Cancel",
+        empty: "Nothing found",
+    },
 };
 export function mergeMessages(overrides) {
     if (!overrides)