@markmo/europacore-session-ui 0.2.0 → 0.4.0

package/dist/api/wire.d.ts

@@ -35,6 +35,19 @@ export interface ServerInfo {
             accept: boolean;
             max_bytes: number;
         };
+        /** The server keeps artifacts, the pages agents make (`/v1/artifacts` and its viewer). */
+        artifacts?: boolean;
+        /** It can take an artifact's permanent published copy down (`POST /v1/artifacts/{id}/unpublish`). */
+        artifact_unpublish?: boolean;
+        /** The server keeps long-term memories (`/v1/memories`, `europacore serve --memory`). */
+        memory?: boolean;
+        /** Sessions list what they load, source by source (`GET /v1/sessions/{sid}/context/sources`). */
+        context_sources?: boolean;
+        /**
+         * It keeps file claims per repository: a session's write to a file another session owns is refused and the
+         * owner's agent is asked for it (`/v1/sessions/{sid}/claims`, spec §3.14). Its sessions' agents message each other.
+         */
+        peers?: boolean;
     };
     principal: {
         workspace_id: string | null;
@@ -79,6 +92,8 @@ export interface AgentInfo {
         permission_modes?: boolean;
         /** An `exit_plan_mode` approval may carry an edited plan (`Resume.plan`). */
         plan_edits?: boolean;
+        /** Its sessions take part in file claims and peer messages (`message_session`, `answer_claim_request`). */
+        peers?: boolean;
     };
     /** The permission modes its sessions may use (Claude Code's: default, acceptEdits, plan, …); empty for none. */
     permission_modes?: string[];
@@ -175,10 +190,13 @@ export interface WorkspaceInfo {
     files: ChangedFile[];
     files_truncated: boolean;
 }
-/** A command or sub-agent running in the background of a session (`tasks.updated`, `/v1/sessions/{sid}/tasks`). */
+/**
+ * A command, sub-agent or monitor running in the background of a session (`tasks.updated`,
+ * `/v1/sessions/{sid}/tasks`). A monitor is a command or file watch whose output wakes the agent.
+ */
 export interface BackgroundTask {
     task_id: string;
-    kind: 'command' | 'subagent';
+    kind: 'command' | 'subagent' | 'monitor';
     title: string;
     state: 'running' | 'completed' | 'failed' | 'stopped';
     /** Running time so far, or in all once finished. */
@@ -190,6 +208,8 @@ export interface BackgroundTask {
     /** The start of a sub-agent's result. */
     summary?: string;
     error?: string;
+    /** A monitor's batches of output so far. */
+    events?: number;
     /** A sub-agent's agent, when the server says (not in the contract yet; the row shows it before the title). */
     agent?: string;
 }
@@ -286,6 +306,237 @@ export interface FleetReviewEntry {
     max_rounds: number;
     attention: 'ready_to_merge' | 'ci_failed' | null;
 }
+export type MemoryScopeName = 'org' | 'user' | 'project';
+export type MemoryRecordKind = 'user' | 'feedback' | 'project' | 'reference';
+export type MemoryRecordStatus = 'active' | 'merged' | 'pruned';
+export type MemoryFlagName = 'stale' | 'duplicate' | 'over_cap' | 'never_recalled' | 'kept';
+export interface MemoryScopeKey {
+    scope: MemoryScopeName;
+    workspace_id: string | null;
+    user_id: string | null;
+    project_id: string | null;
+}
+/** Something to know about a memory; a duplicate names its partner. */
+export interface MemoryFlag {
+    flag: MemoryFlagName;
+    detail: string;
+    partner_id?: string | null;
+    partner_name?: string | null;
+}
+/** One memory. `tokens` and `flags` come from servers that compute them (absent on older ones). */
+export interface MemoryRecord {
+    id: string;
+    key: MemoryScopeKey;
+    kind: MemoryRecordKind;
+    name: string;
+    description: string;
+    body: string;
+    status: MemoryRecordStatus;
+    superseded_by: string | null;
+    source: string;
+    session_id: string | null;
+    revision: number;
+    created_at: string;
+    updated_at: string;
+    last_recalled_at: string | null;
+    recall_count: number;
+    kept_until: string | null;
+    metadata: Record<string, unknown>;
+    tokens?: {
+        index: number;
+        body: number;
+    };
+    flags?: MemoryFlag[];
+    /** `GET /v1/memories/{id}` only: the memory in Claude Code's auto-memory format. */
+    markdown?: string;
+}
+export interface MemoryPatch {
+    kind?: MemoryRecordKind;
+    description?: string;
+    body?: string;
+    /** The revision the change was made against: 409 `memory_changed` when it has moved on. */
+    revision?: number;
+}
+export interface MemoryRevision {
+    id: string;
+    memory_id: string;
+    revision: number;
+    op: string;
+    before: Record<string, unknown> | null;
+    after: Record<string, unknown> | null;
+    actor: string;
+    dream_id: string | null;
+    session_id: string | null;
+    created_at: string;
+}
+export interface MemoryScopeStatus {
+    scope: MemoryScopeName;
+    label: string;
+    project_id?: string | null;
+    active_by_kind: Record<string, number>;
+    index_lines: number;
+    index_chars: number;
+    index_tokens?: number;
+    retired?: number;
+    flags?: Partial<Record<MemoryFlagName, number>>;
+    last_dream: string | null;
+    sessions_since_dream: number;
+    changes_since_dream: number;
+}
+export interface MemoryStatusReport {
+    scopes: MemoryScopeStatus[];
+    /** The caller's own projects with memories. */
+    projects?: string[];
+}
+export type ContextSourceKind = 'system_prompt' | 'tools' | 'instructions' | 'environment' | 'memory_index' | 'memory_preload' | 'skill' | 'plan' | 'hook' | 'other' | 'conversation';
+/** One thing a session's model reads, in load order. */
+export interface ContextSource {
+    n: number;
+    id: string;
+    kind: ContextSourceKind;
+    label: string;
+    origin?: string | null;
+    path?: string | null;
+    scope?: string | null;
+    retention?: string | null;
+    /** sent: the model has it; pending: it reaches the next call; preview: a memory index not pinned yet. */
+    status: 'sent' | 'pending' | 'preview';
+    tokens: number;
+    chars: number;
+    items: number;
+    text?: string | null;
+}
+export interface ContextSources {
+    session_id: string | null;
+    model: string | null;
+    context_window: number | null;
+    estimated_tokens: number;
+    sources: ContextSource[];
+    memory?: {
+        scopes: {
+            scope: MemoryScopeName;
+            label: string;
+            workspace_id: string | null;
+            user_id: string | null;
+            project_id: string | null;
+        }[];
+        writable: boolean;
+        preload_k: number;
+        index_max_lines: number;
+        index_max_chars: number;
+    } | null;
+}
+/**
+ * Who can open an artifact: its owner (`private`, with links that expire), everyone signed in to its workspace
+ * (`workspace`, likewise), or anyone with its link (`public`).
+ */
+export type ArtifactAccess = 'private' | 'workspace' | 'public';
+/** Where a version was put for anyone with the link; a temporary page has a claim link and an expiry. */
+export interface ArtifactPublication {
+    target: string;
+    url: string;
+    claim_url: string | null;
+    expires_at: string | null;
+    created_at?: string | null;
+    /** The session that published it, from servers that keep it. */
+    session_id?: string | null;
+    /** When it was taken down; a copy taken down is no longer up. */
+    removed_at?: string | null;
+}
+/** What the runs that wrote a version spent: each run's tokens since its previous write, other work included. */
+export interface ArtifactUsage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    total_tokens: number;
+    cost_usd?: number | null;
+}
+export interface ArtifactVersionInfo {
+    version: number;
+    created_at: string;
+    /** The version's file paths, the entry among them. */
+    files: string[];
+    published: ArtifactPublication | null;
+    /** The session whose run wrote this version, from servers that keep it; null when unknown. */
+    session_id?: string | null;
+    /** From servers that measure them (absent on older ones). */
+    bytes?: number;
+    usage?: ArtifactUsage | null;
+    /** The git repository the writing session's workspace was in (`owner/repo`); null outside one. */
+    project?: string | null;
+}
+/** Opens of an artifact's page. `people` are others who opened it signed in; `link` the opens of its public link. */
+export interface ArtifactViews {
+    total: number;
+    last_30_days: {
+        opens: number;
+        link: number;
+        own: number;
+        people: number;
+    };
+    /** The latest open by anyone else, or through the public link. */
+    last_viewed_at: string | null;
+}
+/** An artifact as `/v1/artifacts` shows it. `url` is the viewer's: absolute, or server-relative. */
+export interface ArtifactInfo {
+    id: string;
+    title: string;
+    description: string;
+    icon: string | null;
+    format: 'html' | 'markdown' | string;
+    entry: string;
+    version: number;
+    versions: ArtifactVersionInfo[];
+    /** The session that made it; null for one no session made. */
+    session_id: string | null;
+    url: string;
+    published_url: string | null;
+    created_at: string;
+    updated_at: string;
+    /** The latest version's bytes, from servers that measure them. */
+    size?: number | null;
+    /** Summed over the versions that carry usage; `versions` says how many did. */
+    usage?: (ArtifactUsage & {
+        versions: number;
+    }) | null;
+    /** Its versions' repositories, in the order first written; from servers that record them. */
+    projects?: string[];
+    /** Who can open it; absent from servers that keep no access (there, anyone with the link can). */
+    access?: ArtifactAccess;
+    /** When it was first shared beyond its owner; null while private, and for one public from before access. */
+    shared_at?: string | null;
+    /** The owner's user id. */
+    owner?: string | null;
+    /** The caller owns it: false for one shared with the caller. */
+    mine?: boolean;
+    /** When `url` stops opening: a signed link's expiry; null for the public link. */
+    url_expires_at?: string | null;
+    /** How often its page was opened; the owner's only, from servers that count. */
+    views?: ArtifactViews | null;
+}
+/** `GET /v1/artifacts`: the list, and the repository of the session named by `session=`. */
+export interface ArtifactList {
+    artifacts: ArtifactInfo[];
+    project?: string | null;
+    /** Others' artifacts shared with the caller, when asked for (`shared=true`). */
+    shared?: ArtifactInfo[];
+}
+/** A page a session wrote (`artifact_write`), as the server keeps it in `metadata.artifacts`, the newest write last. */
+export interface SessionArtifact {
+    id: string;
+    title: string;
+    version: number;
+    format: string;
+    /** The viewer's url; it carries a token, so it is never shown. */
+    url: string | null;
+    published_url?: string | null;
+    claim_url?: string | null;
+    expires_at?: string | null;
+    target?: string | null;
+    since?: string | null;
+    access?: ArtifactAccess;
+}
 /** A pull request a session opened (or registered), and where its CI and review have got to (`metadata.pull_requests`). */
 export interface SessionPullRequest {
     number: number;
@@ -309,6 +560,144 @@ export interface SessionPullRequest {
     since?: string;
     head_sha?: string;
 }
+/** A session as another session sees it, in a repository's claims: never its transcript. */
+export interface Ref {
+    session_id: string;
+    title: string;
+    user: string;
+    /** One of the caller's own sessions (a teammate's is not). */
+    mine: boolean;
+    /** A session handed off to the cloud, mirrored here. */
+    cloud?: boolean;
+}
+/**
+ * A claim on a path of a repository (`'dir/'` covers what is under it). A `change` claim is the first writer's
+ * while the path has uncommitted changes in that checkout; a `declared` one was claimed or given and holds anywhere
+ * in the repository; a `shared` one has two holders and a boundary between them.
+ */
+export interface Claim {
+    path: string;
+    kind: 'change' | 'declared' | 'shared';
+    holders: Ref[];
+    checkout: string;
+    /** What each holder keeps to, for a shared claim (a `keep` records one too); advisory inside the file. */
+    boundary?: string | null;
+    reason: string;
+    since: string;
+    /** Sessions the path passes to, first come first served, once its holder is done with it. */
+    queue: Ref[];
+}
+/** What the owner does with one path a contender asks for. */
+export type Disposition = 'give' | 'keep' | 'share' | 'after' | 'will_do';
+export type ClaimOutcome = 'handed_over' | 'declined' | 'split' | 'share' | 'after' | 'will_do' | 'released' | 'committed' | 'withdrawn' | 'deleted' | 'user' | 'cycle' | 'expired';
+/**
+ * A contender's request for paths another session owns: the owner answers per path (round 1), the contender may
+ * counter once (round 2), and the owner's reply is final (round 3).
+ */
+export interface ClaimRequest {
+    id: string;
+    paths: string[];
+    contender: Ref;
+    owner: Ref;
+    /** The kind of claim the owner held when the request opened. */
+    owner_kind: Claim['kind'];
+    /** The contender's task, or the reason it gave. */
+    reason: string;
+    /** The refused edit, as a short diff; empty when no write was refused. */
+    change: string;
+    /** How often the owner has written each path. */
+    owner_writes: Record<string, number>;
+    round: 1 | 2 | 3;
+    status: 'open' | 'answered' | 'countered' | 'doing' | 'ended';
+    answer?: Record<string, Disposition> | null;
+    counter?: Record<string, Disposition> | null;
+    boundary?: string | null;
+    note?: string | null;
+    /** Paths the owner has made the contender's change to (a `will_do`). */
+    done?: string[] | null;
+    outcome?: ClaimOutcome | null;
+    since: string;
+}
+/** What a peer message is about: free text (`message_session`), a request and its rounds, or a path come free. */
+export type PeerAbout = 'message' | 'request' | 'answer' | 'counter' | 'done' | 'free' | 'cycle';
+/** A message to a session's agent from another session's (`from`), or from the claims themselves (null). */
+export interface PeerMessage {
+    id: string;
+    from: Ref | null;
+    to: Ref;
+    about: PeerAbout;
+    request_id?: string | null;
+    text: string;
+    at: string;
+}
+/** How a peer message reached its session: drained into a live run, woke it with a notice run, or waits. */
+export type PeerDelivery = 'live' | 'woke' | 'waiting';
+/** `peer.message`, on the recipient's stream. */
+export type PeerMessageEvent = PeerMessage & {
+    delivery?: PeerDelivery;
+};
+/** Another session working in the same repository, with what it holds. */
+export interface PeerSession {
+    session_id: string;
+    title: string;
+    user: string;
+    /** The user owns that session too (not a teammate's). */
+    mine?: boolean;
+    /** A session handed off to the cloud, mirrored here. */
+    cloud?: boolean;
+    checkout: string;
+    running: boolean;
+    claims: Claim[];
+}
+/** `GET /v1/sessions/{sid}/claims`: the session's claims, the other sessions here, and requests to or from it. */
+export interface ClaimsView {
+    repo: string;
+    checkout: string;
+    claims: Claim[];
+    others: PeerSession[];
+    requests: ClaimRequest[];
+    /** Messages waiting for the session's next run. */
+    pending: PeerMessage[];
+    /** 'contested': a request it made could not be settled between the agents, so it needs its user. */
+    attention: string | null;
+    /** Why it needs its user, in the server's words. */
+    attention_reason?: string | null;
+}
+/** `metadata.claims`, which the server owns and writes before it tells the model. */
+export interface MetadataClaims {
+    v: 1;
+    repo: string;
+    checkout: string;
+    /** The paths it has changed and so owns until they are committed. */
+    changed: unknown[];
+    /** The paths it claimed, or was given. */
+    declared: unknown[];
+    /** Its requests, live or settled in the last hour; their `owner` and `contender` are session ids here. */
+    requests: unknown[];
+    pending: PeerMessage[];
+    attention: string | null;
+    attention_reason?: string | null;
+}
+/** `display.kind == 'peer_message'`: what `message_session` sent, and how it was delivered. */
+export interface PeerMessageDisplay {
+    kind: 'peer_message';
+    to: Ref | string;
+    text: string;
+    delivery?: PeerDelivery | null;
+}
+/** `display.kind == 'claim_answer'`: what `answer_claim_request` answered, in which round. */
+export interface ClaimAnswerDisplay {
+    kind: 'claim_answer';
+    request_id: string;
+    round: number;
+    answer?: Record<string, Disposition> | null;
+    /** It accepted the answer (the asker) or the counter (the owner). */
+    accept?: boolean;
+    /** Paths whose promised change it reported made. */
+    done?: string[];
+    boundary?: string | null;
+    note?: string | null;
+}
 /** A fleet run as `GET /v1/fleet/runs` lists it. */
 export interface FleetRunSummary {
     run_id: string;
@@ -436,13 +825,50 @@ export type TranscriptItem = {
     id: string;
     summary?: string;
 }
-/** Put in the history by the harness, not the user: what woke the agent (`task_notice`), a hook's or a recovery's. */
+/**
+ * Put in the history by the harness, not the user: what woke the agent (`task_notice`), a hook's or a recovery's,
+ * or a monitor's output (`monitor`, with its fields).
+ */
  | {
     kind: 'notice';
     id: string;
     origin?: string;
     text: string;
+    monitor?: MonitorOutput;
+}
+/** A message from another session's agent, as the agent read it (a peer, not the user). */
+ | {
+    kind: 'peer';
+    id: string;
+    from?: Ref | null;
+    about?: PeerAbout;
+    request_id?: string | null;
+    text: string;
+    at?: string;
 };
+/** How a monitor ended: its command exited, it reached its timeout, it printed too much, or it was stopped. */
+export interface MonitorEnd {
+    reason: 'exited' | 'timeout' | 'rate' | 'user' | 'stopped';
+    exit_code?: number | null;
+    seconds?: number | null;
+    /** Its batches of output in all. */
+    events?: number;
+    /** The last line of a failed command's stderr. */
+    stderr?: string;
+}
+/**
+ * What the agent was given of a monitor's output (`monitor_output`, and a `monitor` notice in `/messages`): its new
+ * lines (a command's stdout, or `added|modified|deleted <path>` for a file watch), and how it ended.
+ */
+export interface MonitorOutput {
+    monitor_id: string;
+    description: string;
+    kind: 'command' | 'files';
+    lines: string[];
+    /** Lines that arrived but were not passed on. */
+    dropped: number;
+    end: MonitorEnd | null;
+}
 /** `notice`: a run the server started itself, because a background task finished while the session was idle. */
 export type RunKind = 'turn' | 'resume' | 'notice';
 export type RunStatus = 'queued' | 'running' | 'completed' | 'paused' | 'failed' | 'cancelled';
@@ -590,6 +1016,8 @@ export interface McpServer {
 }
 export interface HarnessResult {
     output: Record<string, unknown> | null;
+    /** What to change when the run stopped short (europacore's `agents.stop_hints`); null when it ended normally. */
+    hint?: string | null;
     text?: string | null;
     error: string | null;
     error_code: string | null;
@@ -648,17 +1076,73 @@ export interface AnswersDisplay {
         answer: string;
     }[];
 }
+/**
+ * `display.kind == "artifact"`: a page `artifact_write` made or `artifact_publish` put up (spec §5.2). `url` is the
+ * viewer's, null when the server has none; a publish adds where it went.
+ */
+export interface ArtifactDisplay {
+    kind: 'artifact';
+    id: string;
+    title: string;
+    version: number;
+    format: string;
+    url: string | null;
+    published_url?: string | null;
+    claim_url?: string | null;
+    expires_at?: string | null;
+    target?: string | null;
+    /** Who can open it, from servers that keep access. */
+    access?: ArtifactAccess;
+    /** `artifact_unpublish`: the published copy's address, now taken down. */
+    removed_url?: string | null;
+}
+/** `display.kind == "artifact_deleted"`: the agent's `artifact_delete` removed a page, and the sessions that wrote it. */
+export interface ArtifactDeletedDisplay {
+    kind: 'artifact_deleted';
+    id: string;
+    title: string;
+    sessions?: string[];
+}
 export type ToolDisplay = {
     kind: 'plan';
     plan: PlanItem[];
     summary?: string;
-} | DiffDisplay | ExecDisplay | AnswersDisplay | {
+} | DiffDisplay | ExecDisplay | AnswersDisplay | ArtifactDisplay | ArtifactDeletedDisplay | PeerMessageDisplay | ClaimAnswerDisplay | {
     kind: string;
     [key: string]: unknown;
 };
+export declare function isPeerMessageDisplay(display: ToolDisplay | null | undefined): display is PeerMessageDisplay;
+export declare function isClaimAnswerDisplay(display: ToolDisplay | null | undefined): display is ClaimAnswerDisplay;
+export declare function isArtifactDisplay(display: ToolDisplay | null | undefined): display is ArtifactDisplay;
+export declare function isArtifactDeletedDisplay(display: ToolDisplay | null | undefined): display is ArtifactDeletedDisplay;
 export declare function isDiffDisplay(display: ToolDisplay | null | undefined): display is DiffDisplay;
 export declare function isExecDisplay(display: ToolDisplay | null | undefined): display is ExecDisplay;
 export declare function isAnswersDisplay(display: ToolDisplay | null | undefined): display is AnswersDisplay;
+/** How the model router decided a turn's tier (`model_route`; europacore's docs/model-routing.md). */
+export type RouteBasis = 'choice' | 'probability' | 'baseline' | 'floor' | 'escalation' | 'budget' | 'held' | 'shadow' | 'pinned';
+/** `model_route`: the tier and model a turn runs on, and why; sent per turn and when the tier changes within it. */
+export interface ModelRouteData {
+    /** `fast`, `standard` or `capable`; null when the session's model is not routed (`pinned`). */
+    tier: string | null;
+    /** The model serving the turn (in shadow mode, the one still serving it). */
+    model: string | null;
+    basis: RouteBasis;
+    reason: string;
+    /** The classifier's answer: its tier, confidence and each option's probability. */
+    judged?: string | null;
+    confidence?: number | null;
+    probabilities?: Record<string, number>;
+    classifier?: string | null;
+    latency_ms?: number | null;
+    spent_usd?: number | null;
+    budget_usd?: number | null;
+    /** The model the turn was on before; the cache gate weighed staying on it. */
+    incumbent?: string | null;
+    cache_warm?: boolean | null;
+    /** What staying and switching would cost over the gate's horizon, when it weighed a switch. */
+    stay_usd?: number | null;
+    switch_usd?: number | null;
+}
 export interface TokenUsageData {
     last_call_tokens?: number;
     total_tokens?: number;
@@ -777,3 +1261,55 @@ export interface HandoffFinding {
     line: number | null;
     reason: string;
 }
+/** One run of a session, from its journal (`GET /v1/sessions/{sid}/runs`). */
+export interface RunSummary {
+    run_id: string;
+    status: 'running' | 'completed' | 'failed' | 'paused' | 'cancelled' | 'abandoned' | string;
+    started_at?: string | null;
+    ended_at?: string | null;
+    input?: string | null;
+    steps: number;
+    total_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    cost_usd?: number | null;
+    wall_seconds?: number | null;
+    stop_reason?: string | null;
+    error_code?: string | null;
+    error?: string | null;
+    hint?: string | null;
+}
+/** One tool call of a step, with its arguments and result. */
+export interface ToolCallView {
+    call_id: string;
+    name: string;
+    arguments?: unknown;
+    status?: string | null;
+    result?: string | null;
+}
+/** One step of a run: its model call, tool calls and other events. */
+export interface StepView {
+    step: number;
+    model?: string | null;
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    cost_usd?: number | null;
+    text?: string | null;
+    tools: ToolCallView[];
+    events: {
+        type: string;
+        name?: string | null;
+        data?: Record<string, unknown>;
+    }[];
+}
+/** A run step by step (`GET /v1/sessions/{sid}/runs/{rid}/steps`). */
+export interface RunInspection {
+    summary: RunSummary;
+    session_id?: string | null;
+    steps: StepView[];
+    pause?: Record<string, unknown> | null;
+    output?: unknown;
+}

package/dist/features/artifacts/ArtifactDetail.d.ts

@@ -0,0 +1,15 @@
+import type { ArtifactInfo } from '../../api/wire';
+import { type SessionLink } from '../chat/model/artifacts';
+export type DetailAction = 'access' | 'delete' | 'unpublish';
+export declare function ArtifactDetail({ artifact: a, link, canUnpublish, mentionIn, onAction, sessionTitle, }: {
+    artifact: ArtifactInfo;
+    link: (id: string | null) => SessionLink;
+    canUnpublish: boolean;
+    /** The session `@artifact:<id>` goes into, when the page was opened from one. */
+    mentionIn: {
+        title: string;
+        mention: (text: string) => void;
+    } | null;
+    onAction: (action: DetailAction) => void;
+    sessionTitle: (id: string | null) => string | null;
+}): import("react").JSX.Element;

package/dist/features/artifacts/ArtifactDialogs.d.ts

@@ -0,0 +1,29 @@
+import type { ArtifactInfo } from '../../api/wire';
+import { type ExportScope } from '../chat/model/artifactExport';
+import { type SessionLink } from '../chat/model/artifacts';
+export declare function DeleteArtifactsDialog({ items, link, canUnpublish, onClose, onDone, onMakePrivate, onExport, }: {
+    items: ArtifactInfo[];
+    link: (id: string | null) => SessionLink;
+    canUnpublish: boolean;
+    onClose: () => void;
+    onDone: () => void;
+    /** Make them private instead (`p`). */
+    onMakePrivate: () => void;
+    /** Save a copy first (`s`; a download here, europacorecli's workspace archive). */
+    onExport: () => Promise<void>;
+}): import("react").JSX.Element;
+export declare function AccessDialog({ items, onClose }: {
+    items: ArtifactInfo[];
+    onClose: () => void;
+}): import("react").JSX.Element;
+/** Take a permanent published copy down (`U`), after saying what that does. */
+export declare function UnpublishDialog({ artifact, onClose }: {
+    artifact: ArtifactInfo;
+    onClose: () => void;
+}): import("react").JSX.Element;
+/** The export menu (`X`): CSV of the rows, a ZIP of the files, the page to print, and the source as written. */
+export declare function ExportMenu({ scope, sessionTitle, label, }: {
+    scope: ExportScope;
+    sessionTitle: (id: string | null) => string | null;
+    label?: string;
+}): import("react").JSX.Element;

package/dist/features/artifacts/ArtifactLedger.d.ts

@@ -0,0 +1,11 @@
+import type { ArtifactInfo } from '../../api/wire';
+import { type SortColumn } from '../chat/model/artifacts';
+export declare function ArtifactLedger({ rows, sessionTitle, initialSort, initialDescending, onOpen, onDelete, onAccess, }: {
+    rows: ArtifactInfo[];
+    sessionTitle: (id: string | null) => string | null;
+    initialSort?: SortColumn;
+    initialDescending?: boolean;
+    onOpen: (a: ArtifactInfo) => void;
+    onDelete: (items: ArtifactInfo[]) => void;
+    onAccess: (items: ArtifactInfo[]) => void;
+}): import("react").JSX.Element;