shiitake

Import

Import

import * as api from "@fungi.computer/shiitake";

Exports

Kind	Export	Description
Cclass	ShiitakeError	Sanitized failure from a parsed Shiitake boundary.
Ttype alias	ColdSessionRow	One Session as the store keeper sees it: what it holds and how cold it is.
Ttype alias	ColdSessionPage	One bounded page of Sessions, coldest first.
Ttype alias	ColdSessionPageRequest	A page request: limit is a whole number from 1 to 200 (default 50).
Ttype alias	ShiitakeErrorBoundary	Stable boundary that rejected a Shiitake operation.
Ttype alias	ShiitakeErrorCause	Safe failure category exposed by both Shiitake facades.
Ttype alias	ExtensionCapabilityV0	Closed, versioned, feature-free capability vocabulary.
Ttype alias	ShiitakeApi	Public construction namespace for the Promise-facing durable harness.
Ttype alias	ShiitakeHost	Promise-facing host composition with addressed mail kept off Session.
Ttype alias	PromptDelivery	Delivery policy for input accepted while a Session run is active.
Ttype alias	SessionCommand	Public Session command inferred from its one runtime parser.
Ttype alias	PromptCommand	Public prompt command accepted as durable Session work.
Ttype alias	AbortCommand	Cancel the running turn and all queued prompts, retaining their text.
Ttype alias	CancelCommand	Public command that cancels exactly one accepted request.
Ttype alias	BranchCommand	Public command that selects one complete entry as the active lineage leaf.
Ttype alias	OperatorCommand	Public command that records one operator or party line without a run.
Ttype alias	CompactCommand	Public command that compacts the Session’s context as queued work.
Ttype alias	TitleCommand	Public command that sets or clears the user’s Session title.
Ttype alias	ForkCommand	Public command that creates a new Session from one complete entry lineage.
Ttype alias	SqliteValue	Native SQLite scalar and row grammar shared with the work queue owner.
Ttype alias	SqliteRow	Raw row grammar shared by Woodstock and Watchdog.
Ttype alias	SqliteCursor	Native rows stay raw until the query’s maintained schema decodes them.
Ttype alias	SqliteOwner	Synchronous SQL and transactions held by the surrounding runtime.
Ttype alias	ModelAcquisition	Acquired Pi model and optional explicit Pi stream function.
Ttype alias	ModelSource	Deterministic host seam for model selection and ready egress.
Ttype alias	ModelDescription	What a Session’s footer may know about its selected model.
Ttype alias	InstructionSnapshot	Immutable instruction snapshot captured for one run.
Ttype alias	InstructionSource	Host seam for one bounded instruction snapshot.
Ttype alias	ToolSource	Mycelium construction inputs captured by the Shiitake-owned run scope.
Ttype alias	RuntimePendingWork	Promise host for scheduling the opaque durable reconciler.
Ttype alias	RuntimeHost	Promise host for scheduling the opaque durable reconciler.
Ttype alias	StoragePressureCheck	A host’s storage-pressure check. Shiitake owns the refusal door and the typed storage_pressure error; the host owns the numbers behind it, such as Zookeeper’s budget and thresholds. While the check reports pressure, new Sessions and new prompts are refused and admitted work finishes.
Ttype alias	CompactionBudget	One model’s compaction token budgets; omitted fields fall back.
Ttype alias	CompactionOptions	Pi’s compaction settings. Each budget resolves through the exact provider/modelId override, then the ordinary value, then Pi’s default (16384 reserve, 20000 kept, 32768 background). enabled is global and governs automatic compaction only; a manual compaction always runs.
Ttype alias	ShiitakeOptions	Validated immutable construction bag for the durable harness.
Ttype alias	ToolAccess	A host’s access data for its Agent’s tools. Grants are keyed by module id; a module an extension built is granted by that extension’s id. A missing id keeps full access, so a first-time host writes no permission code.
Ttype alias	ShiitakeOwnerAgent	The in-process owner of a durable harness. Only the host holds it, so only the host can write a Session’s grants or attach metadata; no HTTP or remote client can.
Ttype alias	CommandSettlement	Exact accepted-work facts, independent of the current Session branch or page.
Ttype alias	StandardHostMetaSchema	Any Standard Schema, such as a Zod 4 schema, whose validate settles synchronously. Shiitake only asks whether a value is accepted.
Ttype alias	StandardHostMetaResult	One Standard Schema validation outcome; only acceptance matters here.
Ttype alias	HostMetaOptions	The one schema a host supplies at Agent creation for the metadata it attaches to prompts and operator lines: an Effect schema whose encoded side is JSON, or a synchronous Standard Schema. Shiitake checks each value against it before writing; it never reads the decoded form.
Ttype alias	ModelPreference	Null at the Session boundary means inherit the Agent default.
Ttype alias	VerifiedAgentReply	A delegated Agent’s reply after the admitting host authenticated it.
Ttype alias	GrantsDelivery	One versioned delivery of a Session’s grants.
Ttype alias	GrantsDeliveryResult	Whether a delivery replaced the stored grants or repeated them.
Ttype alias	DocumentForkPolicyV0	Which source value a new Session starts with.
Ttype alias	DocumentSpecV0	A typed JSON document, bounded by its encoded UTF-8 size.
Ttype alias	DocumentsV0	Existential declarations; each initial value is decoded by its own schema.
Ttype alias	DocumentHandleV0	Both operations require the declaring extension’s active core transaction.
Ttype alias	DocumentHandlesV0	Handles preserve the decoded type of each declared document.
constconstant	Shiitake	Construct the Promise facade over the canonical Effect program.
constconstant	sqliteRowSchema	A native row is a scalar record; each query owner decodes its own projection.
fnfunction	parseForkedSession()	Parse one serialized fork result using Shiitake’s public client grammar.
fnfunction	parseSessionSnapshot()	Parse one serialized snapshot using Shiitake’s public client grammar.
fnfunction	parseSessionFrame()	Parse one serialized frame using Shiitake’s public client grammar.
fnfunction	makeHost()	Construct the host-only Promise facade over the canonical Effect program.

ShiitakeErrorCclass

Sanitized failure from a parsed Shiitake boundary.

Extends

• Error

Constructors

Constructor

Signature

new ShiitakeError(
   boundary,
   category,
   message,
   requestId?,
   cause?
): ShiitakeError;

Construct a sanitized boundary failure.

Parameters

Parameter	Type	Description
boundary	| "contract" | "extensions" | "instructions" | "model" | "runtime" | "store" | "tools"	Boundary that rejected the operation.
category	| "closed" | "conflict" | "incompatible" | "invalid" | "rejected" | "unavailable" | "state_reset_required" | "storage_pressure"	Safe category describing why it was rejected.
message	string	Human-readable message safe for callers to display.
requestId?	string	Request identity recoverable when a send may have reached the owner.
cause?	unknown	The original thrown value, kept for server-side diagnosis only. It is never serialized: the wire encoder copies named fields only.

Returns

ShiitakeError

Overrides

Signature

Error.constructor;

Properties

_tag

Signature

readonly _tag: "ShiitakeError";

Stable runtime tag for typed Shiitake failures.

cause

Signature

readonly cause:
  | "closed"
  | "conflict"
  | "incompatible"
  | "invalid"
  | "rejected"
  | "unavailable"
  | "state_reset_required"
  | "storage_pressure";

Safe category describing why it was rejected.

Overrides

Signature

Error.cause;

underlying?

Signature

readonly optional underlying?: unknown;

Original cause retained only for server-side diagnosis.

boundary

Signature

readonly boundary:
  | "contract"
  | "extensions"
  | "instructions"
  | "model"
  | "runtime"
  | "store"
  | "tools";

Boundary that rejected the operation.

requestId?

Signature

readonly optional requestId?: string;

Request identity recoverable when a send may have reached the owner.

ColdSessionRowTtype alias

Signature

type ColdSessionRow = Readonly<{
  sessionId: string;
  bytes: number;
  lastActivityAt: number;
  idle: boolean;
}>;

One Session as the store keeper sees it: what it holds and how cold it is.

---

ColdSessionPageTtype alias

Signature

type ColdSessionPage = Readonly<{
  sessions: readonly ColdSessionRow[];
  next?: string;
}>;

One bounded page of Sessions, coldest first.

---

ColdSessionPageRequestTtype alias

Signature

type ColdSessionPageRequest = Readonly<{
  limit?: number;
  after?: string;
}>;

A page request: limit is a whole number from 1 to 200 (default 50).

---

ShiitakeErrorBoundaryTtype alias

Signature

type ShiitakeErrorBoundary = Schema.Schema.Type<
  typeof ShiitakeErrorBoundarySchema
>;

Stable boundary that rejected a Shiitake operation.

---

ShiitakeErrorCauseTtype alias

Signature

type ShiitakeErrorCause = Schema.Schema.Type<typeof ShiitakeErrorCauseSchema>;

Safe failure category exposed by both Shiitake facades.

---

ExtensionCapabilityV0Ttype alias

Signature

type ExtensionCapabilityV0 =
  | "state"
  | "attention"
  | "settled"
  | "send"
  | "timers"
  | "commands"
  | "projection"
  | "run_tools"
  | "files"
  | "prompt"
  | "compaction_handoff";

Closed, versioned, feature-free capability vocabulary.

---

ShiitakeApiTtype alias

Signature

type ShiitakeApi = Readonly<{
  make: (options) => Promise<ShiitakeOwnerAgent>;
}>;

Public construction namespace for the Promise-facing durable harness.

---

ShiitakeHostTtype alias

Signature

type ShiitakeHost = Readonly<{
  readSettlement: (
    sessionId,
    commandId,
  ) => Promise<CommandSettlement | undefined>;
  agent: ShiitakeOwnerAgent;
  acceptMail: (mail, meta?, reply?, stageAcceptedNotice?) => Promise<Accepted>;
}>;

Promise-facing host composition with addressed mail kept off Session.

---

PromptDeliveryTtype alias

Signature

type PromptDelivery = "steer" | "followUp";

Delivery policy for input accepted while a Session run is active.

---

SessionCommandTtype alias

Signature

type SessionCommand = Schema.Schema.Type<typeof SessionCommandSchema>;

Public Session command inferred from its one runtime parser.

---

PromptCommandTtype alias

Signature

type PromptCommand = Schema.Schema.Type<typeof PromptCommandSchema>;

Public prompt command accepted as durable Session work.

---

AbortCommandTtype alias

Signature

type AbortCommand = Schema.Schema.Type<typeof AbortCommandSchema>;

Cancel the running turn and all queued prompts, retaining their text.

---

CancelCommandTtype alias

Signature

type CancelCommand = Schema.Schema.Type<typeof CancelCommandSchema>;

Public command that cancels exactly one accepted request.

---

BranchCommandTtype alias

Signature

type BranchCommand = Extract<
  SessionCommand,
  Readonly<{
    type: "branch";
  }>
>;

Public command that selects one complete entry as the active lineage leaf.

---

OperatorCommandTtype alias

Signature

type OperatorCommand = Extract<
  SessionCommand,
  Readonly<{
    type: "operator";
  }>
>;

Public command that records one operator or party line without a run.

---

CompactCommandTtype alias

Signature

type CompactCommand = Extract<
  SessionCommand,
  Readonly<{
    type: "compact";
  }>
>;

Public command that compacts the Session’s context as queued work.

---

TitleCommandTtype alias

Signature

type TitleCommand = Extract<
  SessionCommand,
  Readonly<{
    type: "title";
  }>
>;

Public command that sets or clears the user’s Session title.

---

ForkCommandTtype alias

Signature

type ForkCommand = Extract<
  SessionCommand,
  Readonly<{
    type: "fork";
  }>
>;

Public command that creates a new Session from one complete entry lineage.

---

SqliteValueTtype alias

Signature

type SqliteValue = WatchdogSqliteValue;

Native SQLite scalar and row grammar shared with the work queue owner.

---

SqliteRowTtype alias

Signature

type SqliteRow = WatchdogSqliteRow;

Raw row grammar shared by Woodstock and Watchdog.

---

SqliteCursorTtype alias

Signature

type SqliteCursor = WatchdogSqliteCursor &
  Readonly<{
    one: () => SqliteRow;
  }>;

Native rows stay raw until the query’s maintained schema decodes them.

---

SqliteOwnerTtype alias

Signature

type SqliteOwner = Omit<WatchdogSqliteOwner, "sql"> &
  Readonly<{
    sql: Readonly<{
      exec: (statement, ...bindings) => SqliteCursor;
    }>;
    storeName?: string;
  }>;

Synchronous SQL and transactions held by the surrounding runtime.

---

ModelAcquisitionTtype alias

Signature

type ModelAcquisition = Readonly<{
  model: Model<Api>;
  stream?: MuleStreamFunction;
  retryable: (message) => boolean;
  retryAfterMs?: (message) => number | undefined;
  failureReason?: (message) => string | undefined;
  rejection?: (message) => ProviderRejection | undefined;
  providerError?: (message) => string | undefined;
  release: () => Promise<void>;
}>;

Acquired Pi model and optional explicit Pi stream function.

---

ModelSourceTtype alias

Signature

type ModelSource = Readonly<{
  acquire: (input) => Promise<ModelAcquisition>;
  describe?: (input) => Promise<ModelDescription>;
}>;

Deterministic host seam for model selection and ready egress.

---

ModelDescriptionTtype alias

Signature

type ModelDescription = Readonly<{
  contextWindow: number | null;
}>;

What a Session’s footer may know about its selected model.

---

InstructionSnapshotTtype alias

Signature

type InstructionSnapshot = Readonly<{
  revision: string;
  text: string;
  modules?: readonly ModuleRegistration[];
  release?: () => void;
}>;

Immutable instruction snapshot captured for one run.

---

InstructionSourceTtype alias

Signature

type InstructionSource = Readonly<{
  load: (input) => Promise<InstructionSnapshot>;
}>;

Host seam for one bounded instruction snapshot.

---

ToolSourceTtype alias

Signature

type ToolSource = Readonly<{
  execution?: ExecutionOptions;
  modules?: readonly ModuleRegistration[];
  sources?: readonly CapabilitySource[];
  sandbox: Sandbox;
  access?: ToolAccess;
}>;

Mycelium construction inputs captured by the Shiitake-owned run scope.

---

RuntimePendingWorkTtype alias

Signature

type RuntimePendingWork = Readonly<{
  pending: boolean;
  nextWakeAt: number | null;
}>;

Promise host for scheduling the opaque durable reconciler.

---

RuntimeHostTtype alias

Signature

type RuntimeHost = Readonly<{
  bind: (input) => Promise<
    Readonly<{
      commit: <A>(mutation) => Promise<A>;
      requestWake: () => Promise<void>;
      close: () => Promise<void>;
    }>
  >;
}>;

Promise host for scheduling the opaque durable reconciler.

---

StoragePressureCheckTtype alias

Signature

type StoragePressureCheck = Readonly<{
  underPressure: () => boolean;
}>;

A host’s storage-pressure check. Shiitake owns the refusal door and the typed storage_pressure error; the host owns the numbers behind it, such as Zookeeper’s budget and thresholds. While the check reports pressure, new Sessions and new prompts are refused and admitted work finishes.

---

CompactionBudgetTtype alias

Signature

type CompactionBudget = Readonly<{
  reserveTokens?: number;
  keepRecentTokens?: number;
  backgroundTokens?: number;
}>;

One model’s compaction token budgets; omitted fields fall back.

---

CompactionOptionsTtype alias

Signature

type CompactionOptions = CompactionBudget &
  Readonly<{
    enabled?: boolean;
    modelOverrides?: Readonly<Record<string, CompactionBudget>>;
  }>;

Pi’s compaction settings. Each budget resolves through the exact provider/modelId override, then the ordinary value, then Pi’s default (16384 reserve, 20000 kept, 32768 background). enabled is global and governs automatic compaction only; a manual compaction always runs.

---

ShiitakeOptionsTtype alias

Signature

type ShiitakeOptions = Readonly<{
  meta?: HostMetaOptions;
  store: SqliteOwner;
  storagePressure?: StoragePressureCheck;
  compaction?: CompactionOptions;
  runtime: RuntimeHost;
  model: ModelSource;
  instructions: InstructionSource;
  tools?: ToolSource;
  extensions: ExtensionRosterV0;
}>;

Validated immutable construction bag for the durable harness.

---

ToolAccessTtype alias

Signature

type ToolAccess = Pick<
  AccessOptions,
  "grants" | "required" | "confirm" | "onRefused"
>;

A host’s access data for its Agent’s tools. Grants are keyed by module id; a module an extension built is granted by that extension’s id. A missing id keeps full access, so a first-time host writes no permission code.

---

ShiitakeOwnerAgentTtype alias

Signature

type ShiitakeOwnerAgent = ShiitakeAgent &
  Readonly<{
    prepareConfiguration: (configuration) => Promise<
      Readonly<{
        commit: () => void;
        discard: () => Promise<void>;
      }>
    >;
    grants: Readonly<{
      deliver: (sessionId, delivery) => GrantsDeliveryResult;
      read: (sessionId) => GrantsDelivery | null;
    }>;
    withMeta: (meta) => ShiitakeAgent;
  }>;

The in-process owner of a durable harness. Only the host holds it, so only the host can write a Session’s grants or attach metadata; no HTTP or remote client can.

---

CommandSettlementTtype alias

Signature

type CommandSettlement = Readonly<{
  acceptedSender: string | null;
  terminal: SessionTerminal;
  content: string;
  usage: readonly Pick<AssistantMessage, "provider" | "model" | "usage">[];
  toolCalls: number;
}>;

Exact accepted-work facts, independent of the current Session branch or page.

---

StandardHostMetaSchemaTtype alias

Signature

type StandardHostMetaSchema = Readonly<{
  ~standard: Readonly<{
     validate: (value) =>
        | StandardHostMetaResult
       | PromiseLike<StandardHostMetaResult>;
  }>;
}>;

Any Standard Schema, such as a Zod 4 schema, whose validate settles synchronously. Shiitake only asks whether a value is accepted.

---

StandardHostMetaResultTtype alias

Signature

type StandardHostMetaResult =
  | Readonly<{
      issues?: undefined;
    }>
  | Readonly<{
      issues: readonly Readonly<{
        message: string;
      }>[];
    }>;

One Standard Schema validation outcome; only acceptance matters here.

---

HostMetaOptionsTtype alias

Signature

type HostMetaOptions = Readonly<{
  schema: Schema.Codec<unknown, Json> | StandardHostMetaSchema;
  identityPath?: string;
}>;

The one schema a host supplies at Agent creation for the metadata it attaches to prompts and operator lines: an Effect schema whose encoded side is JSON, or a synchronous Standard Schema. Shiitake checks each value against it before writing; it never reads the decoded form.

---

ModelPreferenceTtype alias

Signature

type ModelPreference = Schema.Schema.Type<typeof ModelPreferenceSchema>;

Null at the Session boundary means inherit the Agent default.

---

VerifiedAgentReplyTtype alias

Signature

type VerifiedAgentReply = typeof VerifiedAgentReplySchema.Type;

A delegated Agent’s reply after the admitting host authenticated it.

---

GrantsDeliveryTtype alias

Signature

type GrantsDelivery = Readonly<{
  version: number;
  grants: Grants;
}>;

One versioned delivery of a Session’s grants.

---

GrantsDeliveryResultTtype alias

Signature

type GrantsDeliveryResult = "applied" | "unchanged";

Whether a delivery replaced the stored grants or repeated them.

---

DocumentForkPolicyV0Ttype alias

Signature

type DocumentForkPolicyV0 = "inherit-at-fork-point" | "current" | "fresh";

Which source value a new Session starts with.

---

DocumentSpecV0Ttype alias

Signature

type DocumentSpecV0<A, I> = Readonly<{
  schema: Schema.Codec<A, I>;
  initial: A;
  fork: DocumentForkPolicyV0;
  maxBytes: number;
}>;

A typed JSON document, bounded by its encoded UTF-8 size.

Type Parameters

Type Parameter	Default type
A	-
I	A

---

DocumentsV0Ttype alias

Signature

type DocumentsV0 = Readonly<
  Record<
    string,
    Readonly<{
      schema: Schema.Codec<unknown>;
      initial: unknown;
      fork: DocumentForkPolicyV0;
      maxBytes: number;
    }>
  >
>;

Existential declarations; each initial value is decoded by its own schema.

---

DocumentHandleV0Ttype alias

Signature

type DocumentHandleV0<A> = Readonly<{
  read: (sessionId) => A;
  update: (sessionId, change) => void;
}>;

Both operations require the declaring extension’s active core transaction.

Type Parameters

Type Parameter
A

---

DocumentHandlesV0Ttype alias

Signature

type DocumentHandlesV0<D> = {
  readonly [K in keyof D]: DocumentHandleV0<D[K]["schema"]["Type"]>;
};

Handles preserve the decoded type of each declared document.

Type Parameters

Type Parameter
D extends DocumentsV0

Shiitakeconstconstant

Signature

const Shiitake: ShiitakeApi;

Construct the Promise facade over the canonical Effect program.

---

sqliteRowSchemaconstconstant

Signature

const sqliteRowSchema: Schema.$Record<
  Schema.String,
  Schema.Union<
    readonly [
      Schema.instanceOf<ArrayBuffer, unknown>,
      Schema.String,
      Schema.Number,
      Schema.Null,
    ]
  >
>;

A native row is a scalar record; each query owner decodes its own projection.

parseForkedSession()fnfunction

Signature

function parseForkedSession(value): ForkedSession;

Parse one serialized fork result using Shiitake’s public client grammar.

Parameters

Parameter	Type
value	string

Returns

ForkedSession

---

parseSessionSnapshot()fnfunction

Signature

function parseSessionSnapshot(value): SessionSnapshot;

Parse one serialized snapshot using Shiitake’s public client grammar.

Parameters

Parameter	Type
value	string

Returns

SessionSnapshot

---

parseSessionFrame()fnfunction

Signature

function parseSessionFrame(value): SessionFrame;

Parse one serialized frame using Shiitake’s public client grammar.

Parameters

Parameter	Type
value	string

Returns

SessionFrame

---

makeHost()fnfunction

Signature

function makeHost(options, mailRoom): Promise<Readonly<{
  readSettlement: (sessionId, commandId) => Promise<
     | Readonly<{
     acceptedSender: string | null;
     terminal: SessionTerminal;
     content: string;
     usage: readonly Pick<AssistantMessage, ... | ... | ...>[];
     toolCalls: number;
   }>
    | undefined>;
  agent: ShiitakeOwnerAgent;
  acceptMail: (mail, meta?, reply?, stageAcceptedNotice?) => Promise<Readonly<{
     status: "accepted";
     commandId: string;
     sessionId?: string;
  }>>;
}>>;

Construct the host-only Promise facade over the canonical Effect program.

Parameters

Parameter	Type
options	ShiitakeOptions
mailRoom	BirdDogEffect

Returns

Promise<Readonly<{ readSettlement: (sessionId, commandId) => Promise< | Readonly<{ acceptedSender: string | null; terminal: SessionTerminal; content: string; usage: readonly Pick<AssistantMessage, … | … | …>[]; toolCalls: number; }> | undefined>; agent: ShiitakeOwnerAgent; acceptMail: (mail, meta?, reply?, stageAcceptedNotice?) => Promise<Readonly<{ status: "accepted"; commandId: string; sessionId?: string; }>>; }>>

References

AgentExtensionControls

Re-exports AgentExtensionControls

---

CancelResult

Re-exports CancelResult

---

Accepted

Re-exports Accepted

---

DelegationReceipt

Re-exports DelegationReceipt

---

Held

Re-exports Held

---

ForkedSession

Re-exports ForkedSession

---

SendOptions

Re-exports SendOptions

---

ReadOptions

Re-exports ReadOptions

---

SessionCommandHandler

Re-exports SessionCommandHandler

---

SessionExtensionControls

Re-exports SessionExtensionControls

---

SessionExtensionSlots

Re-exports SessionExtensionSlots

---

SessionFrame

Re-exports SessionFrame

---

SessionMessage

Re-exports SessionMessage

---

SessionProgress

Re-exports SessionProgress

---

SessionToolOutput

Re-exports SessionToolOutput

---

SessionContext

Re-exports SessionContext

---

SessionSnapshot

Re-exports SessionSnapshot

---

SessionInboxState

Re-exports SessionInboxState

---

SessionSummary

Re-exports SessionSummary

---

SessionSummaryPage

Re-exports SessionSummaryPage

---

SessionSummaryRow

Re-exports SessionSummaryRow

---

SessionActivity

Re-exports SessionActivity

---

AgentRunningWork

Re-exports AgentRunningWork

---

SessionTerminal

Re-exports SessionTerminal

---

SessionCompactionMarker

Re-exports SessionCompactionMarker

---

SessionCompactionNotice

Re-exports SessionCompactionNotice

---

SessionCompactionTrigger

Re-exports SessionCompactionTrigger

---

ShiitakeEventSourceConstructor

Re-exports ShiitakeEventSourceConstructor

---

SessionWatch

Re-exports SessionWatch

---

ShiitakeAgent

Re-exports ShiitakeAgent

---

ShiitakeSession

Re-exports ShiitakeSession

---

SubscribeOptions

Re-exports SubscribeOptions

---

TooLate

Re-exports TooLate

---

UnknownRequest

Re-exports UnknownRequest

---

WatchOptions

Re-exports WatchOptions

---

BorrowedCompactionViewV0

Re-exports BorrowedCompactionViewV0

---

CompactionHandoffErrorV0

Re-exports CompactionHandoffErrorV0

---

CompactionHandoffResultV0

Re-exports CompactionHandoffResultV0

---

CompactionHandoffV0

Re-exports CompactionHandoffV0

---

ExtensionGrantV0

Re-exports ExtensionGrantV0

---

ExtensionRosterV0

Re-exports ExtensionRosterV0

---

ExtensionSlotV0

Re-exports ExtensionSlotV0

---

ExtensionStatusV0

Re-exports ExtensionStatusV0

---

RosteredExtensionV0

Re-exports RosteredExtensionV0