@chipschat/conformance 0.0.0-stage → 1.0.0

package/dist/workspace.d.ts

@@ -0,0 +1,893 @@
+/**
+ * The workspace behind the fake: an event log with the door rules the real server applies, and
+ * the projections the scenario reads. Nothing here listens on a port — `fake-chips.ts` is the
+ * door — so every rule can be driven by a plain call.
+ *
+ * What is mirrored, and what is not. Mirrored: the envelope Chips fills in (the clock, the
+ * actor, who decided), the schema check with the protocol's own `parseEvent`, the direction an
+ * event travels, the idempotency key and what a repeat of one means, a run's life, membership,
+ * first answer wins, and — since Phase 5 — who may change a space or who is in it, that an added
+ * participant exists, and that a decision comes from who the ask named (rules 7 to 9, the Phase
+ * 3 review's finding 11); and a room a person asks the harness for, which only a harness that
+ * declares `new_spaces` may be asked (rule 15), and which it claims under a key of its own
+ * (`space.claimed`, the new-space plan's Phase 2); and agents (ADR 0087): the harness's agents, which
+ * rooms hold in its place, the actor rule that reads the harness as its one agent in a room, and
+ * which of them a message is for. Not mirrored, on purpose: the policy engine — nothing here decides an
+ * approval on the spot, every card waits for the person the scenario plays, which is what "ask
+ * first" means and what the handshake reports — and pricing, so a `usage` sent without a cost
+ * is delivered without one. An adapter that passes here has spoken the protocol; what the real
+ * server's dial would have allowed unasked is that server's business.
+ */
+import { type IdGenerator, type JobSpend, type NoteMember, type ReplyingTo, type RoomContext, type RoomFile, type SpaceIcon, type Viewer } from "@chipschat/protocol";
+import { type FakeExchange } from "./exchange.js";
+export interface Principal {
+    readonly kind: "person" | "harness";
+    readonly participantId: string;
+    readonly workspaceId: string;
+    readonly displayName: string;
+}
+/** An event as the log holds it: the envelope's fields lifted out, and the whole event as sent. */
+export interface StoredEvent {
+    readonly seq: number;
+    readonly id: string;
+    readonly type: string;
+    readonly ts: string;
+    readonly space_id: string | null;
+    readonly run_id: string | null;
+    readonly actor: {
+        readonly kind: string;
+        readonly id: string;
+    };
+    readonly idempotency_key: string | null;
+    readonly payload: Readonly<Record<string, unknown>>;
+}
+export type RunState = "queued" | "running" | "waiting" | "done" | "failed" | "cancelled";
+export type Role = "owner" | "member" | "guest";
+export interface RunRow {
+    readonly run_id: string;
+    readonly space_id: string;
+    readonly harness_id: string;
+    /** The agent it is by, when an agent's (ADR 0087). */
+    readonly agent_id?: string | undefined;
+    state: RunState;
+}
+export interface ApprovalRow {
+    readonly approval_id: string;
+    readonly run_id: string;
+    readonly space_id: string | null;
+    readonly expires_at: string;
+    readonly fallback: string;
+    /** Who may answer, as the real server resolves it: person ids; empty means anyone in the room. */
+    readonly approvers: readonly string[];
+    /** Whether the ask matters (ADR 0195): its action's flags and its risk classes, as declared. */
+    readonly matters: boolean;
+    state: "pending" | "resolved";
+    decision: string | null;
+    scope: string | null;
+    reason: string | null;
+    resolved_by: string | null;
+    resolved_at: string | null;
+    updated_input: unknown;
+}
+export interface QuestionRow {
+    readonly ask_id: string;
+    readonly run_id: string;
+    readonly space_id: string | null;
+    readonly questions: readonly {
+        readonly question_id: string;
+        readonly options: readonly {
+            readonly value: string;
+        }[];
+        readonly default_value?: string;
+    }[];
+    state: "pending" | "answered";
+    answered_by: string | null;
+}
+export interface SpaceRow {
+    readonly space_id: string;
+    /** Direct, group, channel or thread, as it was opened: what says whether it may be erased. */
+    readonly kind: string;
+    readonly title: string | undefined;
+    /** Whether a person or a harness last named it: a person's name holds over a harness's. */
+    readonly title_by: "person" | "harness" | undefined;
+    readonly external_key: string | undefined;
+    /**
+     * Who sent `space.created`, or the harness that claimed it: the one harness that may retitle
+     * or close it later (rule 7).
+     */
+    readonly opened_by: string;
+    /** The harness a person asked into it, to claim under a key of its own (rule 15). */
+    readonly asked_of: string | undefined;
+    /** The other harnesses asked with it from the + (ADR 0087's addendum of 30 September). */
+    readonly also_asked_of: readonly string[];
+    /** The harness's home, its Main room: people join it, and no agent but the lead (rule 7). */
+    readonly home: boolean;
+    readonly state: "open" | "closed";
+    /** Who last archived or unarchived it, when anybody has (ADR 0066). */
+    readonly state_by: "person" | "harness" | undefined;
+    readonly created_at: string;
+    readonly members: Map<string, Role>;
+}
+/** A room the harness opened by key, as `GET /v1/harnesses/:id/spaces` lists it. */
+export interface OpenedSpace {
+    readonly space_id: string;
+    readonly key: string;
+    readonly shared: boolean;
+    readonly title: string | null;
+    readonly state: "open" | "closed";
+    readonly moved_by?: "person" | "harness";
+}
+/** A room a person asked the harness for and it has not claimed, as the same listing has it. */
+export interface AskedSpace {
+    readonly space_id: string;
+    readonly asked_by: string;
+    readonly title: string | null;
+    readonly state: "open" | "closed";
+    readonly asked_at: string;
+}
+/** What a claim did, as the door answers it. */
+export interface Claimed {
+    readonly spaceId: string;
+    /** False on a retry with the key that had already claimed it. */
+    readonly claimed: boolean;
+    readonly retitled: boolean;
+}
+export interface StoredBytes {
+    readonly bytes: Uint8Array;
+    readonly mime_type: string;
+    readonly sha256: string;
+    readonly byte_size: number;
+}
+export interface UploadRow {
+    readonly attachment_id: string;
+    readonly filename: string;
+    readonly uploaded_by: string;
+    stored: StoredBytes | undefined;
+}
+/** A URL a harness may fetch an attachment at, for its own token (decision 10). */
+export type Signs = (attachmentId: string) => {
+    url: string;
+    url_expires_at: string;
+};
+/** The wire's word for a refusal, and the HTTP status it becomes. */
+export type RefusalCode = "forbidden" | "not_found" | "invalid_event" | "stale_file";
+export interface Refusal {
+    readonly code: RefusalCode;
+    /** The rule that refused, in the real server's own words for it. */
+    readonly kind: string;
+    readonly message: string;
+    readonly issues?: readonly {
+        readonly path: string;
+        readonly message: string;
+    }[];
+    /** For `agent_elsewhere`: the room the agent is in (ADR 0087). */
+    readonly space_id?: string | undefined;
+}
+/** A refusal as the report reads it: who was refused, for what, and when. */
+export interface Refused extends Refusal {
+    readonly at: string;
+    readonly who: "person" | "harness";
+    readonly type: string | undefined;
+}
+/** A field an event was taken without, because the protocol does not declare it (ADR 0162). */
+export interface Dropped {
+    readonly who: "person" | "harness";
+    readonly type: string;
+    readonly field: string;
+}
+/** Where a task's lane is, for the sender's acknowledgement (M3.5). */
+export interface LaneOpened {
+    readonly lane_id: string;
+    readonly run_id: string;
+    readonly space_id: string;
+}
+export type Outcome = {
+    readonly ok: true;
+    readonly event: StoredEvent;
+    readonly duplicate: boolean;
+    /** For a `task` that opened a lane: where it is. Absent when the task was flattened. */
+    readonly lane?: LaneOpened | undefined;
+    /** A message held from the agents it named (ADR 0097): the count with it, and the ceiling. */
+    readonly held?: {
+        readonly count: number;
+        readonly allowance?: number;
+    } | undefined;
+} | {
+    readonly ok: false;
+    readonly error: Refusal;
+};
+/** A lane the fake opened: the run it is, where it lives, and where its news goes. */
+interface LaneRow {
+    readonly lane_id: string;
+    readonly run_id: string;
+    /** The lead's run that opened it, when the task was sent in one: what a cancel cascades from. */
+    readonly lead_run: string | undefined;
+    readonly home: string;
+    readonly linked: readonly string[];
+    told: boolean;
+}
+export type { Viewer };
+/** One of the harness's agents (ADR 0087): who it takes part in rooms as. */
+export interface AgentRow {
+    readonly agent_id: string;
+    readonly key: string;
+    name: string;
+    /** Its harness's Main agent (ADR 0087, rule 7), or no longer, its default agent Main instead. */
+    lead: boolean;
+    state: "active" | "archived";
+    /** While free, the room an archive took it out of, which an unarchive brings it back to. */
+    released_from?: string | undefined;
+    /** The room it was last taken out of, whatever took it. */
+    last_space?: string | undefined;
+    /** The agent it is a copy of, when it is a fork's copy (ADR 0087, Fork). */
+    readonly forked_from?: string | undefined;
+    /** The face a person chose for it (ADR 0089); absent while it wears its initials. */
+    face?: SpaceIcon | undefined;
+    /** The person who last named it (ADR 0091); while set, its harness does not rename it. */
+    name_by?: string | undefined;
+    /** Deleted by a person (ADR 0095): its key is refused, and it is nobody's to speak as. */
+    deleted?: boolean | undefined;
+}
+/** A deleted agent's key, asked for again (ADR 0095, point 5): deleted stays deleted. */
+export declare class AgentDeleted extends Error {
+    readonly name = "AgentDeleted";
+    constructor();
+}
+/** What came of a fork's copy registered for a room, as the real server answers it. */
+export type ForkAnswer = {
+    readonly attached: true;
+} | {
+    readonly attached: false;
+    readonly why?: string | undefined;
+};
+/** What an agent said while in no room (ADR 0087, rule 6), until it is posted. */
+export interface HeldRow {
+    readonly event_id: string;
+    readonly agent_id: string;
+    readonly said_at: string;
+    readonly text: string;
+    readonly attachments: readonly unknown[];
+}
+/** Somebody the directory names: a person, the harness, or one of its agents. */
+export interface Named {
+    readonly participantId: string;
+    readonly kind: "person" | "harness" | "agent";
+    readonly displayName: string;
+    /** For an agent: the face a person chose for it (ADR 0089), `null` while it has none. */
+    readonly face?: SpaceIcon | null | undefined;
+}
+export interface WorkspaceOptions {
+    readonly workspaceId: string;
+    readonly owner: Principal;
+    readonly harness: Principal;
+    readonly ids: IdGenerator;
+    readonly now: () => Date;
+    /** What the harness declares, as its registration would (ADR 0046). Nothing, by default. */
+    readonly capabilities?: readonly string[] | undefined;
+}
+export declare class Workspace {
+    readonly id: string;
+    readonly owner: Principal;
+    readonly harness: Principal;
+    /** What the harness declares: `new_spaces` is what lets a person ask it for a room. */
+    readonly capabilities: readonly string[];
+    readonly log: StoredEvent[];
+    readonly runs: Map<string, RunRow>;
+    readonly approvals: Map<string, ApprovalRow>;
+    readonly questions: Map<string, QuestionRow>;
+    readonly spaces: Map<string, SpaceRow>;
+    /**
+     * The first name each room asked of the harness holds for its agent there (ADR 0150), and the
+     * person whose naming it is, until the agent takes the harness's place.
+     */
+    private readonly holds;
+    readonly uploads: Map<string, UploadRow>;
+    /** The lanes opened by `task`, by lane id (M3.5). */
+    readonly lanes: Map<string, LaneRow>;
+    /** The harness's agents, by id (ADR 0087). */
+    readonly agents: Map<string, AgentRow>;
+    /** In each room, who took whose place: `membership.replaced`, from → to. */
+    private readonly replaced;
+    /** What free agents said, oldest first (ADR 0087, rule 6). */
+    readonly held: HeldRow[];
+    /** Every event the door turned away, for the report. */
+    readonly refusals: Refused[];
+    /** Every field the door dropped from an event it took, for the report. */
+    readonly dropped: Dropped[];
+    private seq;
+    private readonly byKey;
+    private readonly listeners;
+    private readonly ids;
+    private readonly now;
+    constructor(options: WorkspaceOptions);
+    /** Hear every append, in order. Returns the way to stop hearing. */
+    onAppend(listener: (event: StoredEvent) => void): () => void;
+    head(): number;
+    nowIso(): string;
+    /** The one way an event gets in: filled in, validated, checked against who sent it, appended. */
+    submit(principal: Principal, raw: unknown, extras?: {
+        readonly runId?: string | undefined;
+        readonly idempotencyKey?: string | undefined;
+    }): Outcome;
+    private take;
+    /**
+     * A message said in no room, which went to everybody (agents review, 3); and what each file of a
+     * post was made from (ADR 0099), refusing one made from a version no longer current.
+     */
+    private refuseUnsaid;
+    /**
+     * Who a harness's event is by (ADR 0087, point 2), as the real door reads it: an agent it names
+     * must be its own, and its own id is read as its one agent in the room — refused as ambiguous
+     * where it has several. A room it is in itself, and anything in no room, stay the harness's.
+     */
+    private speakerOf;
+    /** The room an event is in: the one it names, or its run's. */
+    private roomOf;
+    /** The event as its agent's, with the harness beside it, and who decided or spoke with it. */
+    private speakAs;
+    /**
+     * A person adding the harness to a room adds its default agent (ADR 0087's addendum, point 5),
+     * except to a room asked of it from the +, which holds the harness until it claims it.
+     */
+    private addedAsAgent;
+    /** Whether the harness speaks agents: it declared `agents` (ADR 0087's addendum). */
+    speaksAgents(): boolean;
+    /**
+     * The harness's agent for a key: found, renamed when the name has changed, archived or brought
+     * back as `state` says, or registered. A change is keyed by the log's head, as the server's is.
+     * One asked for as Main is the harness's Main from here, and no other is (ADR 0183).
+     */
+    registerAgent(key: string, name: string, options?: Parameters<Workspace["registerOrChange"]>[2]): {
+        agent: AgentRow;
+        created: boolean;
+        renamed: boolean;
+    };
+    private registerOrChange;
+    /**
+     * The agent a key names, and, when a person deleted the last one, the suffix that keys a new
+     * one apart from it. Deleted stays deleted, but for the agent Chips makes for the harness
+     * itself, which is made afresh (ADR 0095, point 5).
+     */
+    private byAgentKey;
+    /**
+     * The names nobody but `except` may be given, as the server keeps them (ADR 0091): the owner's,
+     * every active agent's, and the first names open rooms hold for the harness's agents-to-be but
+     * the one `heldIn` holds (ADR 0150). The harness's own row shares its default agent's name.
+     */
+    private takenNames;
+    /**
+     * The name a known agent has after its harness asks for `wanted`: the name it has where that is
+     * the one asked for or a number of it, a person's name for it whatever is asked, and numbered
+     * when it comes back to find its name taken, as the server's `registerAgent` does.
+     */
+    private nameFor;
+    /**
+     * A person renames an agent, as `PUT /v1/agents/:id/name` does (ADR 0091): refused a name the
+     * owner or another active agent answers to, case and spaces aside; the same name records nothing.
+     */
+    renameAgent(agentId: string, wanted: string): {
+        readonly ok: true;
+        readonly changed: boolean;
+    } | {
+        readonly ok: false;
+        readonly message: string;
+    };
+    /**
+     * The owner archives an agent or brings it back, as `PUT /v1/agents/:id/state` does (ADR 0095):
+     * `agent.updated` with the person as its actor, and rule 9's reactions after it. The Main agent
+     * and a deleted one are refused; the same state again records nothing.
+     */
+    archiveAgent(agentId: string, state: AgentRow["state"]): boolean;
+    /**
+     * The owner deletes an agent, as `DELETE /v1/agents/:id` does (ADR 0095): out of its room, which
+     * is archived when no other agent is left there, then `agent.deleted`, which its harness hears.
+     */
+    deleteAgent(agentId: string): boolean;
+    /**
+     * One of the harness's agents in a room in the place of another of its own there, or of the
+     * harness itself (ADR 0087, Phase 3), as the server's attach door does it.
+     */
+    attachAgent(agentId: string, spaceId: string, replacing: string): {
+        readonly ok: true;
+        readonly attached: boolean;
+    } | {
+        readonly ok: false;
+        readonly kind: "unknown_agent" | "unknown_space" | "invalid";
+    };
+    /**
+     * The agent the harness has in a room it opened or claimed: the key's own, for every harness
+     * (ADR 0087's addendum of 30 September, point 2), named by the room for one that follows its
+     * rooms and after the harness otherwise; its default for a room with no key.
+     */
+    private agentForRoom;
+    /**
+     * The agent a room held a first name for takes it (ADR 0150), as named by the person who held
+     * it, so the harness asking for another later changes nothing. One a person named keeps that.
+     */
+    private nameAsHeld;
+    /**
+     * The harness's agent in its place in a room, once. One that is in another room stays there,
+     * and the harness leaves this one: an agent is in one room at a time.
+     */
+    private agentInPlace;
+    /**
+     * What the real door fills in on a message: the members its @handles name, and who it is for
+     * (M3.3, ADR 0081), by the protocol's own two functions, over what the fake knows. The fake
+     * knows the names of the owner and the harness under test, so only they can be @mentioned; a
+     * harness is any member with a harness id.
+     */
+    private fillAddress;
+    /**
+     * The reply's author and the sender's last aim, as the room reads now: the harness before
+     * its agent took its place there is the agent (ADR 0087).
+     */
+    private asNowIn;
+    /**
+     * Who an @ in a room may name: the owner and the harness where they are in it, and the
+     * harness's agents — its name a handle for its one agent there (ADR 0087's addendum).
+     */
+    private mentionable;
+    /** The sender's `to`, with the harness's id read as its one agent in the room. */
+    private aimedAt;
+    /** The messages said in a space, newest first. */
+    private messagesIn;
+    /**
+     * A reply answers a message said in the room it is said in (ADR 0219), as the real server's
+     * rule: one naming no message is `not_found`, one in another space `invalid_event`.
+     */
+    private refuseOnReply;
+    /** The `message.post` a message id names, wherever it was said. */
+    private saidMessage;
+    /** Who wrote the message a reply answers, when it is in the same space. */
+    private authorOf;
+    /** Where a sender's newest message in a space that says went, `all` for everyone (ADR 0081). */
+    private lastAddressed;
+    /** The lane a task opened, for its acknowledgement; nothing for any other event. */
+    private laneOf;
+    /**
+     * What the real router does with a task, as far as one harness allows (M3.5, ADR 0032): a
+     * task the harness routes to itself opens a lane — a `run.requested` in the home it named,
+     * or in the direct space, with the run seeded there — and any other target is flattened into
+     * a step on the lead's run, since there is nobody else here to route to. A home the harness
+     * is not in is refused the same way.
+     */
+    /**
+     * Where the route card appears: the space the task was sent from, and the space `link_to`
+     * names when the harness is in it — never one it is not (the real router's rule).
+     */
+    private linkedFor;
+    private routeTask;
+    /** The rows a lane is: its run, going in its home, and the lane itself with where its news goes. */
+    private openLane;
+    /** What the lead itself was asked, to name its hop in a lane's trail: its run's goal. */
+    private leadGoal;
+    /**
+     * Cancelling a lead's run cancels the lanes it opened, and theirs, down the chain, as the real
+     * router does. A lane that has ended keeps its ending, and the chain below it is still walked.
+     * No cancel reached a lane anywhere here before (agents review, finding 37).
+     */
+    private cascade;
+    /**
+     * Where a lane lives (ADR 0087, rule 8): the room named, when its agent is there or the room is
+     * no room of the harness's; otherwise the room its agent is in, or, while it is free, a new
+     * room with the person, as the real router has it.
+     */
+    private laneHome;
+    /** The agent a lane to the harness is worked by: the one named, its lead, or its default. */
+    private specialistAgent;
+    /** A task the harness routes to itself or one of its agents, and not to a child. */
+    private toItself;
+    /** The agent of the harness's that works a lane in a home: the one named, or its only one. */
+    private laneAgent;
+    /** A task Chips will not open a lane for: a done step on the lead's run, saying why. */
+    private flatten;
+    /** A lane's run ended: tell the lead, in every space the lane is linked into. */
+    private tellLead;
+    /**
+     * The files a lane's answer carried, handed back to the lead with the summary: the attachments
+     * on the specialist's own messages in the run. A lane that answers with photographs would
+     * otherwise send the lead a sentence about them and nothing else.
+     */
+    private filesOf;
+    /** An event Chips itself appends as `system`: filled in and validated, past the door. */
+    private appendSystem;
+    /** What the transport knows and the sender must not choose, as the real server fills it. */
+    private draftOf;
+    private validate;
+    /** The attachment an upload id stands for: the uploader's, and only once its bytes are in. */
+    private attachmentFor;
+    /** Rule 4: the run the event names. Fills in the run's space when the event names none. */
+    private refuseOnRun;
+    /**
+     * Rule 5: the space the event names, and whether the sender is in it. Answering an approval
+     * and handing one on are the exceptions, judged by rule 9 instead (ADR 0042): whoever the ask
+     * named answers from wherever they are.
+     */
+    private refuseOnMembership;
+    /**
+     * Rule 7: a change to a space comes from somebody with standing in it. A harness retitles or
+     * closes only a space it opened; a guest changes nothing; somebody else is removed only by the
+     * space's owner, where leaving is anyone's. Rule 5 has already said the sender is in the space.
+     */
+    private refuseOnSpaceChange;
+    private refuseOnSpaceUpdate;
+    /** Rule 8: somebody added to a space is somebody — here, the owner or the harness. */
+    private refuseOnParticipant;
+    /**
+     * Rule 15: a room asked of a harness is asked of one that takes new spaces, for it to claim
+     * under a key of its own — so not a thread, which is its parent's, and not a room with a key.
+     */
+    private refuseOnAsking;
+    /**
+     * Rule 9: a decision comes from who the ask named to make it, when it named anyone — from
+     * wherever they are, since being named is standing enough (ADR 0042) — and when it named
+     * nobody, from anyone in the room but a guest (Gate 5), which is where the room is required.
+     */
+    private refuseNotAnApprover;
+    /**
+     * A harness settles an ask of its own run, answered in its own tools (ADR 0079): the ask is of
+     * the run the event names, and that run is the harness's. Once, and never an expiry; This
+     * session and Always are a person's to give. And only an ask that does not matter (SEC-10, ADR
+     * 0195): money, outside messages, deletions and anything irreversible wait for a person. In this
+     * fake nothing hands a harness an ask.
+     */
+    private refuseHarnessAnswer;
+    /**
+     * An ask that named nobody: anyone in the room but a guest, which is where the room is still
+     * asked for, rule 5 having stood aside for every decision since ADR 0042.
+     */
+    private refuseOnAnyone;
+    /**
+     * Who may answer an ask, as the real server resolves the refs a harness sent (ADR 0030):
+     * `owner` is the harness's owner, `any` is everyone in the room, a person id is itself; a
+     * role has nobody but the owner here. Empty means anyone in the room but a guest (Gate 5).
+     * `owner` and a person id resolve wherever that person is, as the real server resolves them
+     * since ADR 0042; `any` and a role are the room's.
+     */
+    private approversOf;
+    /** Rule 6: first answer wins. And an answer names an ask this workspace has. */
+    private refuseSecondAnswer;
+    /** Into the log, then into the projections, then to whoever is listening. */
+    private append;
+    private project;
+    /** An agent registered or changed (ADR 0087). */
+    private projectAgent;
+    /** An agent a person deleted (ADR 0095): marked, and what it was holding dropped. */
+    private projectDeleted;
+    /** An agent's new name, state or face, whichever `agent.updated` carries. */
+    private projectAgentChange;
+    /** Where an agent was last, the room an archive took it from, and what it said meanwhile. */
+    private projectWhereabouts;
+    /** An agent put in a room, taken out of one, or replaced in one. */
+    private projectPlace;
+    private projectRun;
+    private projectAsks;
+    private projectSpace;
+    /**
+     * One member in another's place in a room, keeping its role; and whoever holds a place last is
+     * who what was said in it reads as (ADR 0087, Phase 3).
+     */
+    private replaceMember;
+    /** The open room an agent is in, or nothing while it is free (rule 1). */
+    agentRoom(agentId: string): string | undefined;
+    /**
+     * Why this agent may not work on a room's project (ADR 0220), in the server's words, or nothing
+     * when it may: it is the harness's, not deleted, and in the room now.
+     */
+    refuseOnProject(agentId: string | undefined, spaceId: string): string | undefined;
+    /** A push that moved a room's project forward (ADR 0220), as the server records it. */
+    recordProjectChange(spaceId: string, agentId: string, change: Readonly<Record<string, unknown>>): StoredEvent;
+    /** What the harness's agents route reports of an agent: its room, and how much it holds. */
+    whereabouts(agent: AgentRow): {
+        room: string | null;
+        released_from: string | null;
+        held: number;
+    };
+    /** A reaction's event, once: the real store's idempotency key does this for it. */
+    private appendOnce;
+    /** The harness's own event, once, for a reaction said as the harness. */
+    private appendAsOnce;
+    private readonly reactions;
+    private react;
+    /**
+     * A room's job weighed against its ceiling after each cost reported there (ADR 0118), as the
+     * real `hold-at-ceiling`: from 80% a warning to the room, and at the ceiling the agents paused by
+     * Chips, saying why, unless they are paused already, then the pause's warning. Once each per job.
+     */
+    private holdAtCeiling;
+    /**
+     * What the referee held, handed over once a person acts in the room (ADR 0097), as the real
+     * `hand-over-held`: for each agent, the newest held message that was for it, once.
+     */
+    private handOver;
+    /** A held message's own aim, as it was sent. */
+    private toOf;
+    /** How the agents' talk in a room stands as of a seq (ADR 0097), for what a turn is handed. */
+    exchangeAt(spaceId: string, seq: number): FakeExchange;
+    /** A person pauses the agents in a room, or lets them carry on (ADR 0097). */
+    setExchange(spaceId: string, state: "paused" | "going", by: string): StoredEvent;
+    /**
+     * A person chooses who leads a room, or that nobody does (ADR 0104). The fake keeps no clock, so
+     * it never hands a lead what was nobody's turn on its own; `handToLead` does, when a test says.
+     */
+    setLead(spaceId: string, agentId: string | null, by: string): StoredEvent;
+    /** Who leads a room now (ADR 0104): the agent last chosen, while it is there. */
+    leadOf(spaceId: string): string | undefined;
+    /** A person sets what a room allows a job, or sets it back to the default (ADR 0117). */
+    setSpendCeiling(spaceId: string, usd: number | null, by: string): StoredEvent;
+    /**
+     * What a room's job has spent as of `upto`, against what the room allows a job (ADR 0117), as
+     * Chips works it out: from the last person's act or brief handed in, what the room's `usage`
+     * reports said since, a run's own report being its total so far.
+     */
+    spendOf(spaceId: string, upto: number): JobSpend;
+    /** What was nobody's turn, handed to the room's lead as the sweep would (ADR 0104). */
+    handToLead(spaceId: string, messageEventId: string): StoredEvent | undefined;
+    /** An agent put in a room: said where everyone can see. */
+    private attachedNotice;
+    /** What an agent said while in no room, posted in the room it is in now, oldest first. */
+    private postHeld;
+    /** An agent out of a room: said, with why. */
+    private releasedNotice;
+    /**
+     * Stop the work in a room that somebody is leaving (agents review, findings 10 and 12): one
+     * agent's runs there, or every run there when the room itself is going. Before the leaving is
+     * written, as the real server does it, so the harness is still in the room to hear.
+     */
+    private stopWork;
+    /** Take an agent out of a room, for a reason: its work there is stopped first. */
+    private takeOut;
+    /** A room archived (rule 3): its runs stopped, then its agents released. */
+    private archived;
+    /** A room unarchived (rule 4): the agents its archive released that are still free. */
+    private unarchived;
+    /** An agent archived in its harness (rule 9): out, and the room archived if it was alone. */
+    private agentArchived;
+    /** A room archived because the only agent in it left for good (rule 9, ADR 0095). */
+    private closeIfEmpty;
+    /** An agent restored in its harness: back to the room its archive closed, reopened. */
+    private agentRestored;
+    /**
+     * Rule 16: an agent is in one room at a time; an archived room takes none; the Main agent is
+     * only in its Main room, which takes no other agent; and an agent archived in its harness joins
+     * nothing. All but the first clause below and the archived one are `refuseAgentInto`, the
+     * function the real door and the real store ask (agents review, findings 5 to 8).
+     */
+    private refuseOnAgentMembership;
+    /** The one-room rule for an agent and a room, as the real store's gate asks it. */
+    private refusePlacing;
+    /** Rule 17: the Main agent is not taken out of its Main room (agents review, finding 9). */
+    private refuseOnLeadRemoval;
+    /**
+     * What an agent in no room says (rule 6): held, or, for one never in a room, said in a room
+     * opened with the harness's owner. Naming no room, one in a room says it there.
+     */
+    private holdIfFree;
+    /**
+     * The agent a post is said by, when it is not in the room the post names. Nothing for an agent
+     * in the room it names, and nothing for a room that is gone, which the door refuses and does
+     * not hold for the next (agents review, finding 10).
+     */
+    private speakerOutside;
+    /** Who a harness's post is said by: its agent named, or the one that last left the room named. */
+    private speakerAgent;
+    /** Whether an agent was ever in a room. */
+    private everIn;
+    /** A room with the harness's owner for a free agent: its first words, or a hand-off (rule 8). */
+    private roomWithOwner;
+    /** A claim whose key's agent is in another room: refused. */
+    private refuseElsewhere;
+    /** A room asked of the harness beside another: it answers with its key's agent in its place. */
+    private answer;
+    /** Why an agent may not be moved into a room, or nothing when it may. */
+    private refuseMove;
+    /**
+     * A person gives an agent a face, or its initials back with `null`, as `PUT` and `DELETE
+     * /v1/agents/:id/face` do (ADR 0089): `agent.updated` carrying the face and nothing else, which
+     * every connection hears. The same face again records nothing.
+     */
+    setAgentFace(agentId: string, face: SpaceIcon | null): boolean;
+    /**
+     * A person moves an agent into a room (ADR 0087, point 4): its runs where it was stop, it is
+     * taken out saying where it went, and it is put here. The owner is the one person here.
+     */
+    moveAgent(agentId: string, spaceId: string): {
+        ok: true;
+        moved: boolean;
+        from: string | null;
+    } | {
+        ok: false;
+        error: Refusal;
+    };
+    /**
+     * The person deletes a room (ADR 0067; ADR 0087, rule 5), as `DELETE /v1/spaces/:id` does on
+     * the real server: every run going in it is stopped while its agents are still there, what was
+     * said in it goes from the log, one `space.erased` stays, and each of its agents is told it is
+     * free. Asked to delete the room's one agent too, Chips archives it, and its harness deletes
+     * its side. The owner is the one person here, and owns the harness.
+     */
+    eraseSpace(spaceId: string, options?: {
+        readonly deleteAgent?: boolean;
+    }): {
+        ok: true;
+    } | {
+        ok: false;
+        error: Refusal;
+    };
+    /** A room gone from the log and from every row built from it, as the real erase leaves it. */
+    private forget;
+    /** The newest ask for a copy of this agent in this room, and whether a copy joined for it. */
+    forkAsk(agentId: string, spaceId: string): {
+        readonly event: StoredEvent;
+        readonly answered: boolean;
+    } | undefined;
+    /** Whether an ask still waits for its copy: none joined, and the minute is not up. */
+    private stands;
+    /** Why the owner may not ask for a copy of this agent in this room, or nothing when they may. */
+    private refuseFork;
+    /**
+     * The owner asks for a copy of an agent in a room (ADR 0087, Fork): `agent.fork` there, which
+     * the harness hears. Asked again while an ask stands, it is the same ask.
+     */
+    forkAgent(agentId: string, spaceId: string): {
+        ok: true;
+        asked: boolean;
+        forkId: string;
+    } | {
+        ok: false;
+        error: Refusal;
+    };
+    /**
+     * The harness's copy, registered for the room it was asked for: in the room while the ask
+     * stands, free otherwise, with why, as the real server answers.
+     */
+    answerFork(agentId: string, forkedFrom: string, spaceId: string): ForkAnswer;
+    /** A person's ask for a new agent (ADR 0108), by its id, and whether an agent joined for it. */
+    agentAsk(askId: string): {
+        readonly event: StoredEvent;
+        readonly answered: boolean;
+    } | undefined;
+    /**
+     * The owner asks the harness for a new agent in a room (ADR 0108): `agent.asked` there, which
+     * the harness hears, under the name given or the harness's own, numbered to a free one.
+     */
+    askAgent(spaceId: string, name?: string): {
+        ok: true;
+        askId: string;
+        name: string;
+    } | {
+        ok: false;
+        error: Refusal;
+    };
+    /**
+     * The harness's new agent, registered for the ask it answers: in the ask's room while the ask
+     * stands, free otherwise, with why, as the real server answers.
+     */
+    answerAsk(agentId: string, askId: string, spaceId: string): ForkAnswer;
+    /** Whether this run is a lane's: work the harness routed to one of its own rooms (M3.5). */
+    isLaneRun(runId: string | null): boolean;
+    /** The run of this harness in this space that has not ended, if there is one. */
+    liveRunIn(spaceId: string, harnessId: string): RunRow | undefined;
+    roleOf(spaceId: string, participantId: string): Role | undefined;
+    /** The rooms a participant is in: a harness's, its agents' too (ADR 0087). */
+    memberSpacesOf(participantId: string): string[];
+    /** The harness's agents in a room, in the order they came. */
+    agentsIn(spaceId: string): AgentRow[];
+    /**
+     * A room's members as the room note lists them (ADR 0092): in the order they joined, the harness
+     * in its own right as an agent, and each agent with its harness's name (ADR 0101), as the
+     * server lists them.
+     */
+    noteMembers(spaceId: string): NoteMember[];
+    /** The people, the harness and its agents sharing a space with this participant, themselves included. */
+    participantsVisibleTo(participantId: string): Named[];
+    /**
+     * Who may see an event: the real server's rule, which is the protocol's own function, so the
+     * two cannot differ on it (phase-0-review finding 6; agents review, finding 37).
+     */
+    canSee(event: StoredEvent, viewer: Viewer): boolean;
+    /**
+     * What a participant is handed with the message at `seq` (ADR 0088), as the real server works it
+     * out: the room's lines since it last spoke there, else since it joined, as the room reads now,
+     * the newest that fit its budget. Nothing for a budget of no lines.
+     */
+    contextFor(participantIds: readonly string[], spaceId: string, seq: number, budget: {
+        readonly lines: number;
+        readonly chars: number;
+    }, sign?: Signs): RoomContext | undefined;
+    /** Where the turn that said these words began: its run's first event, else the words. */
+    private turnBegan;
+    /**
+     * The message a reply answers, as the real server hands it over (ADR 0219): its line as the room
+     * reads now, of one taken back only who and when, its files signed, and beside a turn's context
+     * (`handed`), when it is older than those lines, the lines said just before it. Nothing for a
+     * message not said in this room.
+     */
+    replyingToFor(spaceId: string, replyTo: string, handed: RoomContext | undefined, sign?: Signs): (ReplyingTo & {
+        readonly attachments?: readonly Record<string, unknown>[];
+    }) | undefined;
+    /**
+     * What an agent is handed as it joins a room (ADR 0088, point 5): the room's last lines before it
+     * joined, within the budget. Nothing for a budget of no lines.
+     */
+    catchUpFor(spaceId: string, seq: number, budget: {
+        readonly lines: number;
+        readonly chars: number;
+    }, sign?: Signs): RoomContext | undefined;
+    /** A page of a room's lines before a cursor, and its files now, for `GET /v1/spaces/:id/context`. */
+    contextPage(spaceId: string, before: number, limit: number, sign?: Signs): RoomContext;
+    /**
+     * A room's files at their current version, newest first (ADR 0099): as of the event at `upto`,
+     * with it, or as of now. Who posted each as the room reads now.
+     */
+    roomFiles(spaceId: string, most: number, upto?: number, sign?: Signs): RoomFile[];
+    /** One name's versions in a room, newest first, each with what it was made from (ADR 0100). */
+    fileVersions(spaceId: string, name: string, most: number, sign?: Signs): RoomFile[];
+    /** Who posted a room's file, as the room reads now. */
+    private postedBy;
+    private withFiles;
+    /** Who everybody the fake knows is now: the owner, the harness and its agents. */
+    private whoIs;
+    /** A room's lines between two `seq`s, with every edit and deletion there is folded in. */
+    private roomLines;
+    /** Events as lines, as a room reads them now: whose place each took, and who each is. */
+    private linesAsNow;
+    /** A page of the log after `cursor`, as this viewer may see it. */
+    since(cursor: number, limit: number, viewer: Viewer): {
+        events: StoredEvent[];
+        nextCursor: number | null;
+    };
+    /**
+     * The space a harness works in, by its own key: found when it exists, opened for its owner
+     * when it does not (ADR 0024). The key is stored prefixed with the harness's id, as the real
+     * server stores it, so no adapter can name another's space; a shared key — a worktree — is
+     * stored under its own namespace, which a second harness would find (ADR 0033). With one
+     * harness here there is nobody to join it, and `joined` is always false.
+     */
+    openSpace(key: string, title: string | undefined, shared?: boolean): {
+        spaceId: string;
+        created: boolean;
+        joined: boolean;
+    };
+    /**
+     * The room a person asked the harness for, given the harness's key as `space.claimed`, as the
+     * real space door claims it when it is sent a `space_id`: only a room asked of this harness,
+     * that it is still in and that has no key, under a key no other room holds. A retry with the
+     * key that claimed it finds it. The title goes with the claim unless a person named the room.
+     * A refusal is kept with the others, for the report.
+     */
+    claimSpace(spaceId: string, key: string, title: string | undefined): {
+        ok: true;
+        value: Claimed;
+    } | {
+        ok: false;
+        error: Refusal;
+    };
+    /**
+     * A room claimed from the + is led by the agent that took the harness's place in it (ADR 0104),
+     * unless a person chose a lead first: as the real door has it.
+     */
+    private leadFromClaim;
+    private refuseClaim;
+    /** Every room the harness opened or claimed by key, and whether each is on the list. */
+    spacesOpened(): OpenedSpace[];
+    /**
+     * The rooms people asked the harness for that it has not claimed, and is still in as itself:
+     * asked first, or beside another (ADR 0087's addendum of 30 September).
+     */
+    spacesAsked(): AskedSpace[];
+    /** The direct space `POST /v1/harnesses` opens: the owner and the harness, and nobody else. */
+    createDirectSpace(): string;
+    private addMembers;
+    /** A workspace event Chips itself appends: filled in and validated, past the door's rules. */
+    private appendAs;
+    newUpload(principal: Principal, filename: string): UploadRow;
+    storeUpload(principal: Principal, id: string, bytes: Uint8Array): {
+        ok: true;
+        row: UploadRow;
+    } | {
+        ok: false;
+        error: Refusal;
+    };
+}
+//# sourceMappingURL=workspace.d.ts.map