@dispatch-foo/protocol 0.0.0 → 0.2.0

package/dist/untrusted-DJNiucEX-tUd9XZzz.d.ts

@@ -0,0 +1,388 @@
+import { d as REF_TYPES, n as BUILT_IN_KINDS, r as DELIVERY_STATES } from "./constants-CUM7Sm5u.js";
+
+//#region src/address.d.ts
+type Address = string;
+type ParsedAddress = {
+  kind: 'human';
+  handle: string;
+  address: Address;
+} | {
+  kind: 'agent';
+  handle: string;
+  operator: string | null;
+  address: Address;
+} | {
+  kind: 'task';
+  id: string;
+  address: Address;
+} | {
+  kind: 'run';
+  id: string;
+  address: Address;
+} | {
+  kind: 'channel';
+  name: string;
+  address: Address;
+} | {
+  kind: 'a2a';
+  alias: string;
+  address: Address;
+};
+/** An outbound A2A peer's alias: the handle grammar, at most 40 characters. */
+declare const PEER_ALIAS_PATTERN: RegExp;
+declare function parseAddress(raw: string, field?: string): ParsedAddress;
+/** An outbound A2A peer (`a2a:<alias>`); every message it sends is recorded by the daemon. */
+declare function isPeerAddress(address: Address): boolean;
+/** True for senders the ping-pong breaker counts: runs, agents and A2A peers, not the system. */
+declare function isAgentAuthored(address: Address): boolean;
+//#endregion
+//#region src/envelope.d.ts
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+type BuiltInKind = (typeof BUILT_IN_KINDS)[number];
+type MessageKind = BuiltInKind | `x-${string}`;
+/** A ref type the registry lists; a received ref may carry any other identifier. */
+type RefType = (typeof REF_TYPES)[number];
+interface Ref {
+  /** A registered ref type, or any identifier on a ref received from a peer (§4.4). */
+  type: RefType | (string & {});
+  id: string;
+  /** A commit sha for `file` refs; a section anchor for `doc` refs. */
+  at?: string;
+}
+interface Message {
+  id: string;
+  thread: string;
+  replyTo: string | null;
+  from: Address;
+  session?: string;
+  to: Address[];
+  kind: MessageKind;
+  body: string;
+  refs: Ref[];
+  data?: JsonValue;
+  urgent: boolean;
+  blocking: boolean;
+  choices?: string[];
+  choice?: string;
+  wake: 'none' | 'request';
+  createdAt: string;
+  /** The replica that created a remote message; absent when created here. */
+  origin?: string;
+  /** The origin's hybrid clock at send; threads order by it. */
+  hlc?: string;
+}
+interface SendInput {
+  to: Address[];
+  kind: MessageKind;
+  body: string;
+  refs?: Ref[];
+  data?: JsonValue;
+  urgent?: boolean;
+  blocking?: boolean;
+  choices?: string[];
+  choice?: string;
+  replyTo?: string | null;
+  wake?: 'none' | 'request';
+  session?: string;
+  /** The sender's own dedupe key; a repeat returns the first message (A2A §3.3.1). */
+  idempotencyKey?: string;
+}
+declare const MEMORY_GATE_KINDS: readonly ["preference", "convention", "constraint", "hazard", "decision", "fact", "reference"];
+type GateData = {
+  type: 'tool-approval';
+  requestId: string;
+  runId?: string;
+  conversation?: string;
+  tool: string;
+  input: JsonValue;
+  truncated?: true;
+  floor: boolean;
+} | {
+  type: 'scope';
+  paths: string[];
+  reason: string;
+} | {
+  type: 'wake';
+  target: Address;
+  message: string;
+} | {
+  type: 'agent-registration';
+  agent: Address;
+  client: string;
+  requestedBy?: Address;
+  key?: string;
+} | {
+  type: 'overseer-action';
+  conversation: string;
+  actionId: string;
+  summary: string;
+} | {
+  type: 'memory';
+  proposalId: string;
+  action: 'add' | 'supersede' | 'retire';
+  scope: 'project' | 'team';
+  kind: (typeof MEMORY_GATE_KINDS)[number];
+} | {
+  type: 'task-proposal';
+  task: string;
+  proposedBy: Address;
+  message: string;
+} | {
+  type: 'doc';
+  doc: string;
+  proposal: string;
+  taskId?: string;
+  runId?: string;
+};
+/** How validateSendInput judges gates, refs and a missing reply target. */
+interface ValidateOptions {
+  /** The gate types the host implements; default every GATE_TYPES entry. */
+  gateTypes?: ReadonlySet<string>;
+  /** `received` for a message that arrived through a binding: it keeps unknown ref types. */
+  origin?: 'local' | 'received';
+  /** A federated receive: a reply whose target is not stored skips the checks that need it. */
+  parentOptional?: boolean;
+}
+/** The gate payload a message carries, or null when `data` is not a gate. */
+declare function gateOf(message: {
+  data?: JsonValue;
+}): GateData | null;
+declare function isSystemMarker(message: Pick<Message, 'from' | 'data' | 'origin'>, type: 'x-closed' | 'x-breaker'): boolean;
+declare function checkIdempotencyKey(key: string): void;
+declare function validateSendInput(input: SendInput, sender: Address, canDecide: boolean, replyTarget: Message | null, options?: ValidateOptions): void;
+//#endregion
+//#region src/store.d.ts
+type DeliveryState = (typeof DELIVERY_STATES)[number];
+type DeliveryVia = 'direct' | 'channel';
+/** How a federated thread settled an answer; superseded and candidate rows are stored as `message`. */
+type SettledAs = 'pending' | 'accepted' | 'superseded' | 'candidate';
+/** A recipient homed on another replica: the furthest state its homes report. */
+type RemoteState = 'forwarded' | 'held' | 'pushed' | 'notified' | 'read' | 'answered' | 'refused';
+declare const REMOTE_STATES: readonly RemoteState[];
+interface RemoteDelivery {
+  messageId: string;
+  recipient: Address;
+  via: DeliveryVia;
+  state: RemoteState;
+  /** The replicas placement chose for this recipient. */
+  homes: string[];
+  /** The one home that runs a wake request for a task recipient. */
+  wakeAt: string | null;
+  refusedBy: string[];
+  updatedAt: string;
+}
+/** A question's outcome as its settler recorded it: an answer or a close reason. */
+interface Settlement {
+  questionId: string;
+  answerId: string | null;
+  closedReason: string | null;
+  settler: string;
+  at: string;
+}
+/** Per-row facts that are not part of the message itself. */
+interface StoredMeta {
+  /** Local arrival time of a remote message; quotas count by it. */
+  receivedAt?: string;
+  settledAs?: SettledAs;
+}
+interface Delivery {
+  id: string;
+  messageId: string;
+  recipient: Address;
+  runId: string | null;
+  via: DeliveryVia;
+  state: DeliveryState;
+  updatedAt: string;
+}
+type AgentStatus = 'pending' | 'approved' | 'revoked';
+interface AgentRecord {
+  address: Address;
+  displayName: string;
+  client: string;
+  tokenHash: string;
+  status: AgentStatus;
+  muted: boolean;
+  approvedBy: string | null;
+  createdAt: string;
+}
+interface ChannelRecord {
+  name: string;
+  createdAt: string;
+  auto: boolean;
+}
+/** One thread's most recent state: its opening message, its latest message
+ *  (the same one when a thread has only one message), and how many it holds. */
+interface ThreadSummary {
+  thread: string;
+  root: Message;
+  last: Message;
+  count: number;
+}
+interface DeliveryFilter {
+  recipient?: Address;
+  states?: DeliveryState[];
+  runId?: string;
+  messageId?: string;
+  /** Matches recipients starting with this prefix, e.g. `run:`. */
+  recipientPrefix?: string;
+}
+interface MessageStore {
+  transaction<T>(fn: () => T): T;
+  /** `idemKey` is the sender's dedupe key, unique per sender when set. */
+  insertMessage(message: Message, idemKey?: string, meta?: StoredMeta): void;
+  insertDelivery(delivery: Delivery): void;
+  /** Removes one local delivery row; returns whether it existed. */
+  deleteDelivery(id: string): boolean;
+  getMessage(id: string): Message | null;
+  /** The message `from` sent under `key`, or null. */
+  byIdemKey(from: Address, key: string): Message | null;
+  /** Each given message's dedupe key; keyless and unknown ids are left out. */
+  idemKeysFor(messageIds: string[]): Map<string, string>;
+  /** What `address` sent at or after `sinceIso`, oldest first, optionally only these kinds. */
+  messagesFrom(address: Address, sinceIso: string, kinds?: MessageKind[]): Message[];
+  thread(threadId: string): Message[];
+  answersTo(messageId: string): Message[];
+  openBlocking(): Message[];
+  getDelivery(id: string): Delivery | null;
+  deliveries(filter: DeliveryFilter): Delivery[];
+  /** With `expected`, updates only if the row is still in that state; returns whether it changed. */
+  setDelivery(id: string, state: DeliveryState, runId: string | null, at: string, expected?: DeliveryState): boolean;
+  markGateApplied(questionId: string, at: string): void;
+  /** Turns an answer back into a message and records it voided, which reopens its question. */
+  voidAnswer(answerId: string, questionId: string, at: string): boolean;
+  /** Answered gate questions (closes excluded) whose host effect is not yet recorded. */
+  unappliedAnsweredGates(): {
+    question: Message;
+    answer: Message;
+  }[];
+  /** Messages from `from` that arrived at or after `sinceIso`, and not after
+   *  `untilIso` when given; `origin` narrows to one replica's. */
+  countFrom(from: Address, sinceIso: string, urgentOnly: boolean, origin?: string, untilIso?: string): number;
+  /** Messages created in [sinceIso, untilIso] with a delivery to `recipient`; the per-peer quota. */
+  countDeliveredTo(recipient: Address, sinceIso: string, untilIso?: string): number;
+  /** Threads `from` started since `sinceIso` that name an agent, run or task and reach no human. */
+  countAgentThreadsFrom(from: Address, sinceIso: string): number;
+  /** Agent-authored messages in a thread by arrival; a remote `exclude` still counts. */
+  countAgentAuthored(threadId: string, sinceIso: string, exclude: Address): number;
+  /** The row's settled state, or null when unset or the message is unknown. */
+  settledAs(messageId: string): SettledAs | null;
+  /** Rewrites a reply's stored kind and settled state together. */
+  setSettled(messageId: string, kind: 'answer' | 'message', settledAs: SettledAs | null): void;
+  /** Replies to a question that are or were answers, in arrival order. */
+  answerCandidates(questionId: string): {
+    message: Message;
+    settledAs: SettledAs | null;
+  }[];
+  /** Adds a remote recipient's row; returns false when one already exists. */
+  insertRemote(row: RemoteDelivery): boolean;
+  /** Remote recipient rows matching every given field. */
+  remoteDeliveries(filter: {
+    messageId?: string;
+    recipient?: Address;
+    states?: RemoteState[];
+  }): RemoteDelivery[];
+  /** With `expected`, updates only if the row is still in that state; returns whether it changed. */
+  setRemote(messageId: string, recipient: Address, patch: {
+    state?: RemoteState;
+    refusedBy?: string[];
+    homes?: string[];
+  }, at: string, expected?: RemoteState): boolean;
+  /** Removes a remote recipient's row; returns whether it existed. */
+  deleteRemote(messageId: string, recipient: Address): boolean;
+  /** A question's recorded settlement, or null. */
+  settlement(questionId: string): Settlement | null;
+  /** Records or replaces a question's settlement. */
+  putSettlement(settlement: Settlement): void;
+  /** Keeps a settle for a question not stored yet, one per publisher; never read as a settlement. */
+  putEarlySettlement(settlement: Settlement): void;
+  /** The early settles kept for a question, one per publisher. */
+  earlySettlements(questionId: string): Settlement[];
+  /** Drops a question's early settles once it has been stored. */
+  clearEarlySettlements(questionId: string): void;
+  /** Messages created here after `rowid`, oldest first; remote rows are skipped. */
+  messagesAfter(rowid: number, limit: number): {
+    rowid: number;
+    message: Message;
+  }[];
+  /** The highest message rowid, or 0 for an empty store. */
+  maxRowid(): number;
+  ensureChannel(name: string, at: string, auto: boolean): void;
+  channels(): ChannelRecord[];
+  /** Adds a member; false when it was already in the channel. */
+  addMember(channel: string, member: Address, at: string): boolean;
+  removeMember(channel: string, member: Address): boolean;
+  members(channel: string): Address[];
+  channelsOf(member: Address): string[];
+  putAgent(agent: AgentRecord): void;
+  getAgent(address: Address): AgentRecord | null;
+  agentByTokenHash(hash: string): AgentRecord | null;
+  agents(): AgentRecord[];
+}
+//#endregion
+//#region ../core/dist/untrusted-DJNiucEX.d.ts
+
+type DocStatus = 'draft' | 'accepted' | 'archived';
+type RevisionCause = 'create' | 'save' | 'edit' | 'merge' | 'revert' | 'import' | 'restore' | 'proposal' | 'approve' | 'reject' | 'sync';
+type LinkRel = 'spec' | 'plan' | 'context';
+type LinkTargetType = 'task' | 'run' | 'thread' | 'memory' | 'doc';
+interface LinkTarget {
+  type: LinkTargetType;
+  id: string;
+}
+//#endregion
+//#region src/sqliteDb.d.ts
+/**
+ * The slice of a synchronous SQLite driver everything above this module uses.
+ *
+ * It is declared here rather than imported from either driver so that no other
+ * file names `node:sqlite` or `bun:sqlite` — sqliteTaskStore, sqliteRecords and
+ * storeBackend all type their handle as `SqliteDatabase` and stay driver-blind.
+ */
+type SqlValue = null | number | bigint | string | Uint8Array;
+interface SqliteStatement {
+  all(...params: SqlValue[]): unknown[];
+  /** The matched row, or `undefined` when the query matched none. */
+  get(...params: SqlValue[]): unknown;
+  run(...params: SqlValue[]): {
+    changes: number | bigint;
+    lastInsertRowid: number | bigint;
+  };
+}
+interface SqliteDatabase {
+  /**
+   * Which driver module this handle was actually built from.
+   *
+   * It earns its place twice. A test can assert what `openDispatchDb` LOADED
+   * rather than what `sqliteDriver()` would answer, and those are different
+   * claims: the selector returning 'bun:sqlite' proves nothing about the
+   * module the loader reached for. And it brands the interface, so a raw
+   * `bun:sqlite` Database — which is otherwise structurally identical, but
+   * whose `get()` answers a miss with null — can no longer be passed to
+   * anything typed `SqliteDatabase`.
+   */
+  readonly driver: SqliteDriver;
+  prepare(sql: string): SqliteStatement;
+  exec(sql: string): void;
+  close(): void;
+}
+/** The module `openDispatchDb` loads its driver from on the current runtime. */
+type SqliteDriver = 'bun:sqlite' | 'node:sqlite';
+/**
+ * Picks a driver by runtime: Bun gets `bun:sqlite`, everything else
+ * `node:sqlite`.
+ *
+ * Bun is not a runtime that happens to also have `node:sqlite` — it only
+ * gained that module in 1.4.0, and the shipped `dispatch` CLI, the dispatchd
+ * sidecar and the MCP server are single-file binaries compiled with the Bun
+ * pinned in `.prototools`. Loading `node:sqlite` under Bun therefore worked on
+ * a developer machine with a newer Bun on PATH and threw "No such built-in
+ * module: node:sqlite" in every released binary, taking `dispatch migrate` and
+ * every database-backed project with it. Keying off `process.versions.bun`
+ * rather than off a probe means the choice does not silently drift back the
+ * day the pinned Bun is bumped.
+ */
+//#endregion
+export { ValidateOptions as A, parseAddress as B, JsonValue as C, Ref as D, MessageKind as E, Address as F, PEER_ALIAS_PATTERN as I, ParsedAddress as L, gateOf as M, isSystemMarker as N, RefType as O, validateSendInput as P, isAgentAuthored as R, GateData as S, Message as T, SettledAs as _, SqliteDatabase as a, ThreadSummary as b, ChannelRecord as c, DeliveryState as d, DeliveryVia as f, RemoteState as g, RemoteDelivery as h, RevisionCause as i, checkIdempotencyKey as j, SendInput as k, Delivery as l, REMOTE_STATES as m, LinkRel as n, AgentRecord as o, MessageStore as p, LinkTarget as r, AgentStatus as s, DocStatus as t, DeliveryFilter as u, Settlement as v, MEMORY_GATE_KINDS as w, BuiltInKind as x, StoredMeta as y, isPeerAddress as z };
+//# sourceMappingURL=untrusted-DJNiucEX-tUd9XZzz.d.ts.map