runling 0.1.1

package/dist/src/tui.js

@@ -0,0 +1,477 @@
+import { ansiColor } from "./ansi.js";
+import { stripVTControlCharacters } from "node:util";
+import { Input as TextInput, Key, ProcessTerminal, matchesKey, truncateToWidth, TuiMainScreen, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
+import { renderMarkdown } from "./markdown.js";
+import { totalTokens } from "./usage.js";
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const paint = (color, text) => {
+    const ansi = ansiColor(color);
+    return ansi ? `${ansi}${text}\x1b[39m` : text;
+};
+const bold = (text) => `\x1b[1m${text}\x1b[22m`;
+const dim = (text) => `\x1b[2m${text}\x1b[22m`;
+export class RunlingDashboard {
+    title;
+    startedAt;
+    nodes = [];
+    nodesById = new Map();
+    agents = new Map();
+    inputEditors = new Map();
+    logSequence = 0;
+    usage = {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+    };
+    execution;
+    constructor(title, startedAt = performance.now()) {
+        this.title = title;
+        this.startedAt = startedAt;
+    }
+    handle = (event) => {
+        switch (event.type) {
+            case "log":
+                if (event.source !== "step" &&
+                    event.source !== "agent" &&
+                    event.source !== "command" &&
+                    event.source !== "input") {
+                    this.addNode({
+                        type: "log",
+                        id: `log:${this.logSequence++}`,
+                        parentId: event.activityId,
+                        event,
+                    });
+                }
+                break;
+            case "step.started":
+                this.addNode({
+                    type: "step",
+                    id: event.id,
+                    parentId: event.activityId,
+                    label: event.label,
+                    status: "running",
+                });
+                break;
+            case "step.finished": {
+                const step = this.nodesById.get(event.id);
+                if (step?.type === "step") {
+                    step.status = event.status;
+                    step.durationMs = event.durationMs;
+                }
+                break;
+            }
+            case "command.started":
+                this.addNode({
+                    type: "command",
+                    id: event.id,
+                    parentId: event.activityId,
+                    command: event.command,
+                    status: "running",
+                });
+                break;
+            case "command.finished": {
+                const command = this.nodesById.get(event.id);
+                if (command?.type === "command") {
+                    command.status = event.status;
+                    command.durationMs = event.durationMs;
+                    command.output = event.output;
+                }
+                break;
+            }
+            case "input.requested":
+                this.addNode({
+                    type: "input",
+                    id: event.id,
+                    parentId: event.activityId,
+                    message: event.message,
+                    status: "waiting",
+                });
+                break;
+            case "input.finished": {
+                const input = this.nodesById.get(event.id);
+                if (input?.type === "input") {
+                    input.status = event.status;
+                    if (event.status === "answered")
+                        input.value = event.value;
+                    input.durationMs = event.durationMs;
+                }
+                break;
+            }
+            case "agent.started": {
+                const existing = this.agents.get(event.agentId);
+                if (existing !== undefined) {
+                    existing.parentId = event.activityId;
+                    existing.model = event.model;
+                    existing.color = event.color;
+                    existing.action = "Starting";
+                    existing.outcome = undefined;
+                    break;
+                }
+                const agent = {
+                    type: "agent",
+                    id: `agent:${event.agentId}`,
+                    parentId: event.activityId,
+                    agentId: event.agentId,
+                    model: event.model,
+                    color: event.color,
+                    action: "Starting",
+                };
+                this.agents.set(event.agentId, agent);
+                this.addNode(agent);
+                break;
+            }
+            case "agent.action": {
+                const agent = this.agents.get(event.agentId);
+                if (agent !== undefined)
+                    agent.action = event.action;
+                break;
+            }
+            case "agent.finished": {
+                const agent = this.agents.get(event.agentId);
+                if (agent !== undefined)
+                    agent.outcome = event.outcome;
+                break;
+            }
+            case "usage.updated":
+                this.usage = event.usage;
+                break;
+        }
+    };
+    finish(execution) {
+        this.execution = execution;
+        this.usage = execution.usage;
+    }
+    invalidate() { }
+    setInputEditor(id, editor) {
+        if (editor === undefined)
+            this.inputEditors.delete(id);
+        else
+            this.inputEditors.set(id, editor);
+    }
+    render(width) {
+        return [
+            ...this.renderHeader(width),
+            ...this.renderTranscript(width),
+            ...this.renderFooter(width),
+        ];
+    }
+    renderHeader(width) {
+        const columns = Math.max(1, Math.floor(width));
+        const status = this.execution
+            ? this.execution.ok
+                ? paint("limegreen", "✓")
+                : paint("crimson", "✗")
+            : paint("dodgerblue", this.spinner());
+        return [
+            fit(`${bold(paint("dodgerblue", "◆ Runling"))}  ${this.title}  ${status}`, columns),
+        ];
+    }
+    renderTranscript(width) {
+        const columns = Math.max(1, Math.floor(width));
+        const lines = [];
+        for (const node of this.nodes) {
+            if (!this.hasParent(node)) {
+                lines.push(...this.renderNode(node, 1, columns));
+            }
+        }
+        const result = this.execution?.result;
+        if (result !== undefined && result !== null) {
+            const markdown = result.details === undefined
+                ? result.summary
+                : `${result.summary}\n\n${result.details}`;
+            lines.push("", ...renderMarkdown(markdown, columns).split("\n"));
+        }
+        return lines.map((line) => fit(line, columns));
+    }
+    renderFooter(width) {
+        const columns = Math.max(1, Math.floor(width));
+        const elapsed = formatElapsed(this.execution?.durationMs ?? performance.now() - this.startedAt);
+        return [
+            dim("─".repeat(columns)),
+            fit(this.footer(elapsed), columns),
+        ];
+    }
+    footer(elapsed) {
+        const steps = this.nodes.filter((node) => node.type === "step");
+        const completed = steps.filter(({ status }) => status === "completed").length;
+        const failed = steps.filter(({ status }) => status === "failed").length;
+        const waitingForInput = this.nodes.some((node) => node.type === "input" && node.status === "waiting");
+        const status = this.execution
+            ? this.execution.ok
+                ? "Completed"
+                : "Failed"
+            : waitingForInput
+                ? "Waiting for input…"
+                : "Working…";
+        const tokens = totalTokens(this.usage);
+        const parts = [
+            status,
+            elapsed,
+            `${tokens.toLocaleString("en-US")} tokens`,
+        ];
+        const cacheableInput = this.usage.input + this.usage.cacheRead;
+        if (this.usage.cacheRead > 0 && cacheableInput > 0) {
+            parts.push(`${Math.round((this.usage.cacheRead / cacheableInput) * 100)}% cached`);
+        }
+        parts.push(formatCost(this.usage.cost ?? 0));
+        if (steps.length > 0) {
+            parts.push(failed > 0
+                ? `${failed} failed, ${completed}/${steps.length} steps`
+                : `${completed}/${steps.length} steps`);
+        }
+        return dim(parts.join("  ·  "));
+    }
+    addNode(node) {
+        this.nodes.push(node);
+        this.nodesById.set(node.id, node);
+    }
+    hasParent(node) {
+        return node.parentId !== undefined && this.nodesById.has(node.parentId);
+    }
+    renderNode(node, depth, width) {
+        const indent = "  ".repeat(depth);
+        let lines;
+        switch (node.type) {
+            case "step": {
+                const marker = node.status === "completed"
+                    ? paint("limegreen", "✓")
+                    : node.status === "failed"
+                        ? paint("crimson", "✗")
+                        : paint("dodgerblue", "●");
+                const duration = node.durationMs === undefined
+                    ? ""
+                    : ` ${dim(`· ${formatStepDuration(node.durationMs)}`)}`;
+                lines = [fit(`${indent}${marker} ${node.label}${duration}`, width)];
+                break;
+            }
+            case "command": {
+                const marker = node.status === "completed"
+                    ? paint("limegreen", "✓")
+                    : node.status === "failed"
+                        ? paint("crimson", "✗")
+                        : paint("#ae3ec9", "●");
+                const verb = node.status === "running" ? "Running" : "Ran";
+                const duration = node.durationMs === undefined
+                    ? ""
+                    : ` ${dim(`· ${formatStepDuration(node.durationMs)}`)}`;
+                lines = this.wrapNode(`${indent}${marker} `, `${bold(paint("#ae3ec9", verb))} ${node.command}${duration}`, width);
+                if (node.status === "failed" && node.output !== undefined) {
+                    for (const outputLine of failureOutput(node.output)) {
+                        lines.push(...this.wrapNode(`${indent}  ${paint("crimson", "│")} `, dim(outputLine), width));
+                    }
+                }
+                break;
+            }
+            case "agent": {
+                const marker = node.outcome === undefined
+                    ? paint(node.color, this.spinner())
+                    : node.outcome === "completed"
+                        ? paint("limegreen", "✓")
+                        : node.outcome === "blocked"
+                            ? paint("#f59f00", "!")
+                            : paint("crimson", "✗");
+                lines = [
+                    fit(`${indent}${marker} ${paint(node.color, `[${node.agentId}]`)} ${dim(`· ${node.model}`)}`, width),
+                ];
+                if (node.outcome === undefined) {
+                    lines.push(...this.wrapNode(`${indent}  ${paint(node.color, "↳")} `, node.action, width));
+                }
+                break;
+            }
+            case "input": {
+                const marker = node.status === "answered"
+                    ? paint("limegreen", "✓")
+                    : node.status === "failed"
+                        ? paint("crimson", "✗")
+                        : paint("#f59f00", "?");
+                const duration = node.durationMs === undefined
+                    ? ""
+                    : ` ${dim(`· ${formatStepDuration(node.durationMs)}`)}`;
+                lines = this.wrapNode(`${indent}${marker} `, `${node.message}${node.value === undefined ? "" : ` ${dim("→")} ${node.value}`}${duration}`, width);
+                const editor = this.inputEditors.get(node.id);
+                if (node.status === "waiting" && editor !== undefined) {
+                    const prefix = `${indent}  `;
+                    const continuation = " ".repeat(visibleWidth(prefix));
+                    const editorLines = editor.render(Math.max(1, width - visibleWidth(prefix)));
+                    lines.push(...editorLines.map((line, index) => fit(`${index === 0 ? prefix : continuation}${line}`, width)));
+                }
+                break;
+            }
+            case "log": {
+                const { event } = node;
+                const marker = event.level === "success"
+                    ? "✓"
+                    : event.level === "error"
+                        ? "✗"
+                        : event.level === "debug"
+                            ? "·"
+                            : "●";
+                lines = this.wrapNode(`${indent}${paint(event.color, marker)} `, event.message, width);
+                break;
+            }
+        }
+        if (node.type !== "step" || node.status !== "completed") {
+            for (const child of this.nodes) {
+                if (child.parentId === node.id) {
+                    lines.push(...this.renderNode(child, depth + 1, width));
+                }
+            }
+        }
+        return lines;
+    }
+    wrapNode(prefix, text, width) {
+        const continuation = " ".repeat(visibleWidth(prefix));
+        const wrapped = wrapTextWithAnsi(text, Math.max(1, width - visibleWidth(prefix)));
+        return wrapped.map((line, index) => fit(`${index === 0 ? prefix : continuation}${line}`, width));
+    }
+    spinner() {
+        return SPINNER[Math.floor((performance.now() - this.startedAt) / 80) % SPINNER.length];
+    }
+}
+export class TuiReporter {
+    onCancel;
+    dashboard;
+    tui;
+    timer;
+    started = false;
+    stopped = false;
+    pendingInputs = new Set();
+    pendingEditors = new Set();
+    constructor(title, terminal = new ProcessTerminal(), onCancel = () => {
+        process.kill(process.pid, "SIGINT");
+    }) {
+        this.onCancel = onCancel;
+        this.dashboard = new RunlingDashboard(title);
+        this.tui = new TuiMainScreen(terminal);
+        this.tui.addChild(this.dashboard);
+        this.tui.addInputListener((data) => {
+            if (!matchesKey(data, Key.ctrl("c")))
+                return;
+            this.stop();
+            this.onCancel();
+            return { consume: true };
+        });
+    }
+    handle = (event) => {
+        this.dashboard.handle(event);
+        if (event.type === "input.finished")
+            this.tui.renderNow();
+        else
+            this.tui.requestRender();
+    };
+    input = (request) => {
+        if (!this.started || this.stopped) {
+            return Promise.reject(new Error("The TUI cannot request input while stopped"));
+        }
+        return new Promise((resolve, reject) => {
+            let editor;
+            const settle = (result) => {
+                request.signal?.removeEventListener("abort", abort);
+                this.pendingInputs.delete(cancel);
+                this.pendingEditors.delete(editor);
+                this.dashboard.setInputEditor(request.id, undefined);
+                this.tui.setFocus([...this.pendingEditors].at(-1) ?? null);
+                this.tui.requestRender();
+                if ("value" in result)
+                    resolve(result.value);
+                else
+                    reject(result.error);
+            };
+            const cancel = (error) => settle({ error });
+            const abort = () => cancel(request.signal?.reason instanceof Error
+                ? request.signal.reason
+                : new Error("Input cancelled"));
+            editor = new InlineInput(request, (value) => settle({ value }), () => cancel(new Error(`Input cancelled: ${request.message}`)));
+            this.pendingInputs.add(cancel);
+            this.pendingEditors.add(editor);
+            request.signal?.addEventListener("abort", abort, { once: true });
+            this.dashboard.setInputEditor(request.id, editor);
+            this.tui.setFocus(editor);
+            this.tui.requestRender();
+        });
+    };
+    start() {
+        this.started = true;
+        this.tui.start();
+        this.timer = setInterval(() => this.tui.requestRender(), 80);
+        this.timer.unref();
+    }
+    finish(execution) {
+        this.dashboard.finish(execution);
+        this.tui.renderNow();
+    }
+    stop() {
+        if (!this.started || this.stopped)
+            return;
+        this.stopped = true;
+        for (const cancel of [...this.pendingInputs]) {
+            cancel(new Error("The TUI stopped while waiting for input"));
+        }
+        if (this.timer !== undefined)
+            clearInterval(this.timer);
+        this.tui.stop();
+    }
+}
+class InlineInput {
+    request;
+    input = new TextInput();
+    constructor(request, onSubmit, onCancel) {
+        this.request = request;
+        if (request.defaultValue !== undefined) {
+            for (const character of request.defaultValue) {
+                this.input.handleInput(character);
+            }
+        }
+        this.input.onSubmit = onSubmit;
+        this.input.onEscape = onCancel;
+    }
+    get focused() {
+        return this.input.focused;
+    }
+    set focused(value) {
+        this.input.focused = value;
+    }
+    handleInput(data) {
+        this.input.handleInput(data);
+    }
+    invalidate() {
+        this.input.invalidate();
+    }
+    render(width) {
+        return this.input.render(Math.max(1, Math.floor(width)));
+    }
+}
+const fit = (line, width) => truncateToWidth(line, width, "");
+const formatElapsed = (durationMs) => {
+    const seconds = Math.max(0, Math.floor(durationMs / 1000));
+    const minutes = Math.floor(seconds / 60);
+    return minutes > 0
+        ? `${minutes}m ${String(seconds % 60).padStart(2, "0")}s`
+        : `${seconds}s`;
+};
+const formatStepDuration = (durationMs) => durationMs < 1000
+    ? `${Math.round(durationMs)}ms`
+    : `${(durationMs / 1000).toFixed(1)}s`;
+const formatCost = (cost) => cost === 0
+    ? "$0.00"
+    : cost < 0.0001
+        ? "<$0.0001"
+        : `$${cost.toFixed(cost < 0.01 ? 4 : 2)}`;
+const COMMAND_FAILURE_LINES = 8;
+const failureOutput = ({ stdout, stderr, }) => {
+    const lines = stripVTControlCharacters([stdout.trimEnd(), stderr.trimEnd()].filter(Boolean).join("\n"))
+        .split("\n")
+        .map((line) => line.trimEnd());
+    while (lines[0]?.trim() === "")
+        lines.shift();
+    while (lines.at(-1)?.trim() === "")
+        lines.pop();
+    if (lines.length <= COMMAND_FAILURE_LINES)
+        return lines;
+    const omitted = lines.length - COMMAND_FAILURE_LINES;
+    return [
+        `… ${omitted.toLocaleString("en-US")} earlier lines omitted`,
+        ...lines.slice(-COMMAND_FAILURE_LINES),
+    ];
+};

package/dist/src/usage.d.ts

@@ -0,0 +1,35 @@
+export interface TokenUsage {
+    /** Non-cached input tokens. */
+    input: number;
+    /** Output tokens (including reasoning tokens when reported). */
+    output: number;
+    /** Input tokens served from the prompt cache. */
+    cacheRead: number;
+    /** Input tokens written to the prompt cache. */
+    cacheWrite: number;
+    /** Provider/model-aware cost in US dollars, when reported by Pi. */
+    cost?: number;
+    /** Some recorded tokens have no reported price. */
+    costIncomplete?: boolean;
+}
+type TokenUsageInput = Omit<TokenUsage, "cost"> & {
+    cost?: number | {
+        total?: number;
+    };
+};
+export declare function emptyTokenUsage(): TokenUsage;
+/** Accumulate `usage` into `total` in place. Missing or malformed usage is ignored. */
+export declare function accumulateTokenUsage(total: TokenUsage, usage: TokenUsageInput | undefined): TokenUsage;
+/** Sum of all tracked token counts; zero means nothing was recorded. */
+export declare function totalTokens(usage: TokenUsage): number;
+export declare function formatTokenUsage(usage: TokenUsage): string;
+export declare function isTokenUsage(value: unknown): value is TokenUsage;
+/** Keep token totals local to one execution, including its parallel agents. */
+export declare const withTokenUsage: <T>(work: () => T) => T;
+/** Add one agent interaction's usage to the workflow-wide totals. */
+export declare function recordTokenUsage(usage: TokenUsageInput): void;
+/** Workflow-wide token usage accumulated via `recordTokenUsage`. */
+export declare function getRecordedTokenUsage(): TokenUsage;
+/** Reset workflow-wide totals, e.g. at the start of a workflow execution. */
+export declare function resetTokenUsage(): void;
+export {};

package/dist/src/usage.js

@@ -0,0 +1,90 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { emitRunlingEvent } from "./events.js";
+export function emptyTokenUsage() {
+    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+}
+/** Accumulate `usage` into `total` in place. Missing or malformed usage is ignored. */
+export function accumulateTokenUsage(total, usage) {
+    if (!hasValidTokenCounts(usage)) {
+        return total;
+    }
+    total.input += usage.input;
+    total.output += usage.output;
+    total.cacheRead += usage.cacheRead;
+    total.cacheWrite += usage.cacheWrite;
+    const cost = readCost(usage.cost);
+    if (cost !== undefined)
+        total.cost = (total.cost ?? 0) + cost;
+    if (usage.costIncomplete ||
+        (cost === undefined &&
+            usage.input + usage.output + usage.cacheRead + usage.cacheWrite > 0))
+        total.costIncomplete = true;
+    return total;
+}
+/** Sum of all tracked token counts; zero means nothing was recorded. */
+export function totalTokens(usage) {
+    return usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function formatCount(value) {
+    return value.toLocaleString("en-US");
+}
+export function formatTokenUsage(usage) {
+    const parts = [
+        `in ${formatCount(usage.input)}`,
+        `out ${formatCount(usage.output)}`,
+    ];
+    if (usage.cacheRead > 0 || usage.cacheWrite > 0) {
+        parts.push(`cache read ${formatCount(usage.cacheRead)}`);
+        parts.push(`cache write ${formatCount(usage.cacheWrite)}`);
+    }
+    return parts.join(", ");
+}
+export function isTokenUsage(value) {
+    if (!hasValidTokenCounts(value))
+        return false;
+    const usage = value;
+    return ((usage.costIncomplete === undefined ||
+        typeof usage.costIncomplete === "boolean") &&
+        (usage.cost === undefined ||
+            (Number.isFinite(usage.cost) && usage.cost >= 0)));
+}
+const hasValidTokenCounts = (value) => {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const usage = value;
+    return [usage.input, usage.output, usage.cacheRead, usage.cacheWrite].every((count) => Number.isSafeInteger(count) && count >= 0);
+};
+const readCost = (cost) => {
+    const value = typeof cost === "number" ? cost : cost?.total;
+    return value !== undefined && Number.isFinite(value) && value >= 0
+        ? value
+        : undefined;
+};
+let recordedUsage = emptyTokenUsage();
+const executionUsage = new AsyncLocalStorage();
+/** Keep token totals local to one execution, including its parallel agents. */
+export const withTokenUsage = (work) => executionUsage.run(emptyTokenUsage(), work);
+/** Add one agent interaction's usage to the workflow-wide totals. */
+export function recordTokenUsage(usage) {
+    accumulateTokenUsage(executionUsage.getStore() ?? recordedUsage, usage);
+    emitRunlingEvent({
+        type: "usage.updated",
+        usage: getRecordedTokenUsage(),
+    });
+}
+/** Workflow-wide token usage accumulated via `recordTokenUsage`. */
+export function getRecordedTokenUsage() {
+    return { ...(executionUsage.getStore() ?? recordedUsage) };
+}
+/** Reset workflow-wide totals, e.g. at the start of a workflow execution. */
+export function resetTokenUsage() {
+    const current = executionUsage.getStore();
+    if (current) {
+        Object.assign(current, emptyTokenUsage());
+        delete current.cost;
+        delete current.costIncomplete;
+    }
+    else {
+        recordedUsage = emptyTokenUsage();
+    }
+}

package/dist/src/utils.d.ts

@@ -0,0 +1,2 @@
+export type ConcatPart = string | readonly ConcatPart[];
+export declare function concat(...parts: ConcatPart[]): string;

package/dist/src/utils.js

@@ -0,0 +1,16 @@
+export function concat(...parts) {
+    const lines = [];
+    const append = (part) => {
+        if (typeof part === "string") {
+            lines.push(part);
+            return;
+        }
+        for (const nestedPart of part) {
+            append(nestedPart);
+        }
+    };
+    for (const part of parts) {
+        append(part);
+    }
+    return lines.join("\n");
+}

package/dist/src/web-config.d.ts

@@ -0,0 +1,16 @@
+import { type Workflow } from "./workflow.ts";
+import type { TSchema } from "typebox";
+export interface WebhookDefinition<WorkflowInputSchema extends TSchema, WorkflowOutputSchema extends TSchema> {
+    workflow: Workflow<WorkflowInputSchema, WorkflowOutputSchema>;
+}
+type AnyWebhookDefinition = {
+    workflow: ((...args: any[]) => unknown) & Pick<Workflow, "name" | "input" | "output">;
+};
+export interface WebConfig<Webhooks extends Record<string, AnyWebhookDefinition> = Record<string, AnyWebhookDefinition>> {
+    webhooks: Webhooks;
+}
+/** Preserve webhook names and schema types in a Runling web configuration. */
+export declare function defineWebConfig<const Webhooks extends Record<string, AnyWebhookDefinition>>(config: WebConfig<Webhooks>): WebConfig<Webhooks>;
+/** Check the runtime shape of a Runling web configuration. */
+export declare function isWebConfig(value: unknown): value is WebConfig;
+export {};

package/dist/src/web-config.js

@@ -0,0 +1,22 @@
+import { isWorkflow } from "./workflow.js";
+/** Preserve webhook names and schema types in a Runling web configuration. */
+export function defineWebConfig(config) {
+    return config;
+}
+/** Check the runtime shape of a Runling web configuration. */
+export function isWebConfig(value) {
+    if (typeof value !== "object" ||
+        value === null ||
+        !("webhooks" in value) ||
+        typeof value.webhooks !== "object" ||
+        value.webhooks === null ||
+        Array.isArray(value.webhooks)) {
+        return false;
+    }
+    return Object.values(value.webhooks).every((definition) => typeof definition === "object" &&
+        definition !== null &&
+        "workflow" in definition &&
+        isWorkflow(definition.workflow) &&
+        !("body" in definition) &&
+        !("input" in definition));
+}

package/dist/src/web-server.d.ts

@@ -0,0 +1,8 @@
+export declare function parseRunlingWebArguments(argv: readonly string[]): {
+    port: number;
+    config: string;
+    host: string;
+    open: boolean;
+    help: boolean;
+};
+export declare function runRunlingWeb(argv?: string[]): Promise<void>;