esoul-sdk 0.3.0

package/dist/server.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Server half of a plugin package (`server.ts` in your plugin folder).
+ * Runs ONLY inside the ExternalSoul host (imported by the generic
+ * webhook/op routes) — it may use prisma, node crypto, provider SDKs.
+ *
+ * Outside the host these exports are typed stubs that throw with a clear
+ * message, so an author's unit tests fail loudly rather than mysteriously.
+ * Inside the host, `esoul-sdk/server` is aliased to the real
+ * implementations.
+ */
+export interface PluginWebhookContext {
+    /** Raw request — read body/headers; VERIFY THE PROVIDER'S SIGNATURE
+     * YOURSELF (timing-safe!). The platform does no auth on webhooks. */
+    request: Request;
+    method: string;
+    pluginId: string;
+    hookName: string;
+    /** Kick one of THIS plugin's durable tasks
+     * (`<applicationType>/<taskName>` only — no cross-app injection). */
+    sendInngestEvent(name: string, data: Record<string, unknown>): Promise<void>;
+}
+export type PluginWebhookHandler = (ctx: PluginWebhookContext) => Promise<Response>;
+export interface PluginOpContext {
+    pluginId: string;
+    opName: string;
+    workspaceId: string;
+    nodeId: string;
+    instanceName: string;
+    /** The instance's bound connection (or null). Resolve credentials via
+     * getPluginConnectionCredentials. */
+    cloudConnectionId: string | null;
+    /** Caller-supplied args — validate before use. */
+    args: unknown;
+}
+export type PluginOpHandler = (ctx: PluginOpContext) => Promise<unknown>;
+export interface PluginServerModule {
+    webhooks?: Record<string, PluginWebhookHandler>;
+    ops?: Record<string, PluginOpHandler>;
+}
+export type PluginConnectionCredentials = {
+    kind: "oauth2";
+    accessToken: string;
+} | {
+    kind: "apiKey";
+    apiKey?: string;
+    headers?: Record<string, string>;
+};
+/**
+ * Read the sealed credentials of a plugin-declared connection (auto-
+ * refreshes expiring OAuth tokens). HOST-ONLY.
+ */
+export declare function getPluginConnectionCredentials(_connectionId: string, _pluginId: string): Promise<PluginConnectionCredentials>;
+export interface EmitPluginAppEventArgs {
+    source: {
+        pluginId: string;
+        workspaceId: string;
+        nodeId: string;
+        applicationType: string;
+    };
+    targetNodeId: string;
+    eventName: string;
+    eventData: Record<string, unknown>;
+}
+/**
+ * Cross-app events: dispatch the TARGET app's own events through the
+ * platform spine (target's dataCreator mints; triggers fire; every event is
+ * actor-stamped `{kind:"plugin", pluginId, sourceNodeId}`). Same-workspace
+ * only. HOST-ONLY.
+ */
+/**
+ * Read one app's state folded to head, by nodeId — server truth for an op or
+ * a task. Null when no such app exists. HOST-ONLY.
+ */
+export declare function readAppState(_nodeId: string): Promise<{
+    nodeId: string;
+    workspaceId: string;
+    applicationType: string;
+    foldedSeq: number;
+    state: Record<string, unknown>;
+} | null>;
+export interface CallWorkspaceToolArgs {
+    pluginId: string;
+    nodeId: string;
+    tool: string;
+    args?: Record<string, unknown>;
+    appType?: string;
+    targetNodeId?: string;
+}
+/**
+ * Call another app's tool from the server half (an op, task or webhook) —
+ * how an app orchestrates a my_computer or writes a spreadsheet from a job.
+ * Gated by the manifest's `workspaceTools` grants, same-workspace only.
+ * HOST-ONLY.
+ */
+export declare function callWorkspaceTool(_a: CallWorkspaceToolArgs): Promise<{
+    ok: boolean;
+    text: string;
+}>;
+export declare function emitPluginAppEvent(_args: EmitPluginAppEventArgs): Promise<{
+    ok: true;
+    targetNodeId: string;
+    eventName: string;
+}>;
+import type { FileEntry, FileRef, FileSource } from "./files.js";
+export interface FileProviderContext {
+    workspaceId: string;
+    userId: string;
+    connectionId?: string;
+    localMount?: {
+        id: string;
+        path: string;
+        label?: string;
+    };
+}
+export interface FileReadResult {
+    bytes: Buffer;
+    name: string;
+    contentType?: string;
+}
+/**
+ * A file provider your plugin CONTRIBUTES (manifest `fileProviders` +
+ * `pluginServer.fileProviders[key]`): the browse/read half of a mount backed
+ * by one of your declared connections. The host derives one mount per
+ * ACTIVE connection and calls you with `ctx.connectionId` set — resolve
+ * credentials yourself via `getPluginConnectionCredentials`. A backend that
+ * cannot answer must THROW FileSourceError("source_unavailable"), never
+ * return an empty listing; reads must respect `capBytes`.
+ */
+export interface PluginFileProviderImpl {
+    list(ctx: FileProviderContext, sourceId: string, folderRef?: string, cursor?: string): Promise<{
+        entries: FileEntry[];
+        next?: string;
+    }>;
+    read(ctx: FileProviderContext, sourceId: string, ref: string, capBytes: number): Promise<FileReadResult>;
+}
+export interface FilesApi {
+    sources(): Promise<FileSource[]>;
+    list(sourceId: string, folderRef?: string, cursor?: string): Promise<{
+        entries: FileEntry[];
+        next?: string;
+    }>;
+    read(ref: FileRef, opts?: {
+        capBytes?: number;
+    }): Promise<{
+        bytes: Buffer;
+        name: string;
+        contentType?: string;
+    }>;
+    getUrl(ref: FileRef): Promise<string | null>;
+    saveWorkspaceFile(args: {
+        name: string;
+        bytes: Buffer | Uint8Array | string;
+        contentType?: string;
+        folderPath?: string;
+    }): Promise<{
+        fileId: string;
+        name: string;
+        blobPath: string;
+        deduped: boolean;
+    }>;
+    importToWorkspace(ref: FileRef, opts?: {
+        folderPath?: string;
+        capBytes?: number;
+    }): Promise<{
+        fileId: string;
+        name: string;
+        blobPath: string;
+        deduped: boolean;
+    }>;
+}
+export interface PluginFilesCtx {
+    pluginId: string;
+    workspaceId: string;
+    sourceNodeId?: string;
+    applicationType?: string;
+}
+/**
+ * The consent-enforcing files API for plugin server code. Every call
+ * re-checks your manifest `fileSources` grant (explicit-only — no grant, no
+ * files); workspace writes re-check the kill switch; saves/imports append
+ * `workspace/file_added` with your plugin stamped as the actor. HOST-ONLY.
+ */
+export declare function pluginFiles(_ctx: PluginFilesCtx): Promise<FilesApi>;
+/** Bind the files API straight from an op/task context. HOST-ONLY. */
+export declare function filesForOp(_ctx: {
+    pluginId: string;
+    workspaceId: string;
+    nodeId?: string;
+}): Promise<FilesApi>;

package/dist/server.js

@@ -0,0 +1,58 @@
+/**
+ * Server half of a plugin package (`server.ts` in your plugin folder).
+ * Runs ONLY inside the ExternalSoul host (imported by the generic
+ * webhook/op routes) — it may use prisma, node crypto, provider SDKs.
+ *
+ * Outside the host these exports are typed stubs that throw with a clear
+ * message, so an author's unit tests fail loudly rather than mysteriously.
+ * Inside the host, `esoul-sdk/server` is aliased to the real
+ * implementations.
+ */
+const hostOnly = (name) => {
+    throw new Error(`${name} runs only inside the ExternalSoul host (the app aliases esoul-sdk to its real implementations). In unit tests, mock this module.`);
+};
+/**
+ * Read the sealed credentials of a plugin-declared connection (auto-
+ * refreshes expiring OAuth tokens). HOST-ONLY.
+ */
+export function getPluginConnectionCredentials(_connectionId, _pluginId) {
+    return hostOnly("getPluginConnectionCredentials");
+}
+/**
+ * Cross-app events: dispatch the TARGET app's own events through the
+ * platform spine (target's dataCreator mints; triggers fire; every event is
+ * actor-stamped `{kind:"plugin", pluginId, sourceNodeId}`). Same-workspace
+ * only. HOST-ONLY.
+ */
+/**
+ * Read one app's state folded to head, by nodeId — server truth for an op or
+ * a task. Null when no such app exists. HOST-ONLY.
+ */
+export function readAppState(_nodeId) {
+    return hostOnly("readAppState");
+}
+/**
+ * Call another app's tool from the server half (an op, task or webhook) —
+ * how an app orchestrates a my_computer or writes a spreadsheet from a job.
+ * Gated by the manifest's `workspaceTools` grants, same-workspace only.
+ * HOST-ONLY.
+ */
+export function callWorkspaceTool(_a) {
+    return hostOnly("callWorkspaceTool");
+}
+export function emitPluginAppEvent(_args) {
+    return hostOnly("emitPluginAppEvent");
+}
+/**
+ * The consent-enforcing files API for plugin server code. Every call
+ * re-checks your manifest `fileSources` grant (explicit-only — no grant, no
+ * files); workspace writes re-check the kill switch; saves/imports append
+ * `workspace/file_added` with your plugin stamped as the actor. HOST-ONLY.
+ */
+export function pluginFiles(_ctx) {
+    return hostOnly("pluginFiles");
+}
+/** Bind the files API straight from an op/task context. HOST-ONLY. */
+export function filesForOp(_ctx) {
+    return hostOnly("filesForOp");
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,20 @@
+export interface MockOAuthServer {
+    port: number;
+    url: string;
+    close(): Promise<void>;
+}
+/**
+ * A real (tiny) OAuth2 provider for exercising the plugin-connection flow:
+ * /authorize (PKCE challenge bound to a one-time code), /token
+ * (authorization_code with verifier check + refresh_token grant), and a
+ * Bearer-gated /api/items resource. Access tokens expire fast (default 20s)
+ * so refresh paths are exercised without waiting.
+ *
+ * Point a manifest connection's authorizeUrl/tokenUrl at it and set the
+ * declared clientIdEnv to `clientId` below.
+ */
+export declare function startMockOAuth(opts?: {
+    port?: number;
+    clientId?: string;
+    accessTtlMs?: number;
+}): Promise<MockOAuthServer>;

package/dist/testing/index.js

@@ -0,0 +1,121 @@
+/**
+ * Test utilities that need NOTHING from the host.
+ */
+import http from "node:http";
+import crypto from "node:crypto";
+/**
+ * A real (tiny) OAuth2 provider for exercising the plugin-connection flow:
+ * /authorize (PKCE challenge bound to a one-time code), /token
+ * (authorization_code with verifier check + refresh_token grant), and a
+ * Bearer-gated /api/items resource. Access tokens expire fast (default 20s)
+ * so refresh paths are exercised without waiting.
+ *
+ * Point a manifest connection's authorizeUrl/tokenUrl at it and set the
+ * declared clientIdEnv to `clientId` below.
+ */
+export function startMockOAuth(opts) {
+    const PORT = opts?.port ?? 39997;
+    const CLIENT_ID = opts?.clientId ?? "mock-client";
+    const TTL = opts?.accessTtlMs ?? 20_000;
+    const codes = new Map();
+    const accessTokens = new Map();
+    const refreshTokens = new Set();
+    const b64url = (buf) => Buffer.from(buf).toString("base64url");
+    const sha256 = (s) => crypto.createHash("sha256").update(s).digest();
+    const issueTokens = () => {
+        const access = `mock-access-${crypto.randomUUID()}`;
+        const refresh = `mock-refresh-${crypto.randomUUID()}`;
+        accessTokens.set(access, Date.now() + TTL);
+        refreshTokens.add(refresh);
+        const idToken = [
+            b64url(Buffer.from(JSON.stringify({ alg: "none", typ: "JWT" }))),
+            b64url(Buffer.from(JSON.stringify({ sub: "mock-user-1" }))),
+            "",
+        ].join(".");
+        return {
+            access_token: access,
+            refresh_token: refresh,
+            expires_in: Math.floor(TTL / 1000),
+            token_type: "Bearer",
+            scope: "demo.read",
+            id_token: idToken,
+        };
+    };
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", `http://127.0.0.1:${PORT}`);
+        const json = (status, body) => {
+            res.writeHead(status, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(body));
+        };
+        if (req.method === "GET" && url.pathname === "/authorize") {
+            const clientId = url.searchParams.get("client_id");
+            const redirectUri = url.searchParams.get("redirect_uri");
+            const state = url.searchParams.get("state") ?? "";
+            const challenge = url.searchParams.get("code_challenge");
+            if (clientId !== CLIENT_ID)
+                return json(400, { error: "bad client_id" });
+            if (!redirectUri || !challenge)
+                return json(400, { error: "missing params" });
+            const code = `mock-code-${crypto.randomUUID()}`;
+            codes.set(code, { challenge, redirectUri });
+            const back = new URL(redirectUri);
+            back.searchParams.set("code", code);
+            back.searchParams.set("state", state);
+            res.writeHead(302, { Location: back.toString() });
+            return res.end();
+        }
+        if (req.method === "POST" && url.pathname === "/token") {
+            let raw = "";
+            for await (const chunk of req)
+                raw += chunk;
+            const p = new URLSearchParams(raw);
+            if (p.get("client_id") && p.get("client_id") !== CLIENT_ID) {
+                return json(400, { error: "bad client_id" });
+            }
+            const grant = p.get("grant_type");
+            if (grant === "authorization_code") {
+                const entry = codes.get(p.get("code") ?? "");
+                if (!entry)
+                    return json(400, { error: "bad code" });
+                codes.delete(p.get("code"));
+                if (b64url(sha256(p.get("code_verifier") ?? "")) !== entry.challenge) {
+                    return json(400, { error: "pkce verification failed" });
+                }
+                if (p.get("redirect_uri") !== entry.redirectUri) {
+                    return json(400, { error: "redirect_uri mismatch" });
+                }
+                return json(200, issueTokens());
+            }
+            if (grant === "refresh_token") {
+                if (!refreshTokens.has(p.get("refresh_token") ?? "")) {
+                    return json(400, { error: "bad refresh_token" });
+                }
+                return json(200, issueTokens());
+            }
+            return json(400, { error: "unsupported grant_type" });
+        }
+        if (req.method === "GET" && url.pathname === "/api/items") {
+            const token = (req.headers.authorization ?? "").replace(/^Bearer\s+/i, "");
+            const exp = accessTokens.get(token);
+            if (!exp)
+                return json(401, { error: "unknown token" });
+            if (exp < Date.now())
+                return json(401, { error: "token expired" });
+            return json(200, {
+                items: [
+                    { id: "m1", text: "row one from the mock provider" },
+                    { id: "m2", text: "row two from the mock provider" },
+                ],
+            });
+        }
+        json(404, { error: "not found" });
+    });
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(PORT, "127.0.0.1", () => resolve({
+            port: PORT,
+            url: `http://127.0.0.1:${PORT}`,
+            close: () => new Promise((r) => server.close(() => r())),
+        }));
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,226 @@
+/**
+ * The plugin contract — mirrored from the ExternalSoul platform.
+ *
+ * Inside the host repo, `esoul-sdk` is aliased to the real
+ * platform modules, so these mirrors are used only OUT of the repo (editor
+ * IntelliSense, `tsc` in an author's folder, the validator CLI). A drift
+ * gate in the host asserts assignability between these and the platform's
+ * own types on every build — the mirror cannot silently rot.
+ */
+import type { ComponentType } from "react";
+import type { z } from "zod";
+/** Identity every app state extends — set by the platform, never by you. */
+/**
+ * MIRRORS the host's `ApplicationIdentifier` (venus-sdk.ts) exactly.
+ *
+ * It used to carry `[extra: string]: unknown`, meaning to say "your state may
+ * add fields". That broke the drift gate's FORWARD assertion in a way no error
+ * message explains: TypeScript never infers an implicit index signature for an
+ * interface, so the HOST identifier was not assignable to this one, and every
+ * schema member taking an identifier (`toolkitCreator`, `getPorts`, `events`,
+ * `publicSharing`) failed contravariantly. Extra fields need no index
+ * signature — a plugin declares them the way the reference packages do:
+ *   `export interface PluginTodoData extends ApplicationIdentifier { items: … }`
+ */
+export interface ApplicationIdentifier {
+    workspaceId: string;
+    nodeId: string;
+    applicationType: string;
+    instanceName: string;
+    /**
+     * Set ONLY by the MCP storefront's `executeAppTool`: the external caller a
+     * tool runs for. Chat / agent / voice toolkits never set it.
+     */
+    externalActor?: {
+        kind?: "external" | "sandbox";
+        userId: string;
+        email: string | null;
+        handle: string | null;
+        viaProfileId: string;
+        sessionId: string;
+        anonymous?: boolean;
+    };
+}
+export declare enum EventTypes {
+    Client = "Client",
+    Workflow = "Workflow",
+    Workspace = "Workspace"
+}
+export interface EventData<T = unknown> {
+    eventName: string;
+    workspaceId: string;
+    applicationId: string | undefined;
+    instanceName: string | undefined;
+    /** REQUIRED-but-maybe-undefined, exactly as the host declares it. An
+     *  OPTIONAL `chatIdSource?: string` is not assignable to the host's
+     *  required member, which silently broke the drift gate's forward
+     *  assertion for every event definition. */
+    chatIdSource: string | undefined;
+    eventData: T;
+    timestamp: number;
+}
+export interface CollapsibleConfig {
+    /** Same key within the window ⇒ events merge (newest content wins). */
+    collapseKeyFn: (eventData: any, context: EventData<any>) => string;
+    collapseWindowMs: number;
+}
+export interface TriggerMeta {
+    displayName?: string;
+    description?: string;
+    sampleVariables?: string[];
+    payloadShape?: "single" | "batch";
+    batchAccessor?: string;
+}
+export type EventReversibility = "pure" | "external-reversible" | "external-irreversible";
+/**
+ * MIRRORS the host (event-spec.ts). This mirror used to declare
+ * `EventSideEffect` as the bare string union above, so an author writing
+ * `sideEffect: "external-irreversible"` type-checked against the SDK and was
+ * rejected by the platform — the drift gate exists for exactly this.
+ *
+ * The scrub/revert kernel reads it: `reversibility` says whether undoing the
+ * event can undo its effect on the outside world, and an `inverseEventName` +
+ * `buildInverseEventData` let the platform actually compensate.
+ */
+export interface EventSideEffect {
+    reversibility: EventReversibility;
+    description?: string;
+    inverseEventName?: string;
+    buildInverseEventData?: (forwardEventData: any, parentEvent: EventData<any>) => any;
+    criticality?: "status" | "normal";
+}
+export interface EventDefinition<StateType extends ApplicationIdentifier> {
+    eventName: string;
+    type: EventTypes;
+    /** Mints the full envelope. IDS AND TIMESTAMPS ARE MINTED HERE — never in
+     * the processor (replay determinism). */
+    dataCreator: (params: Record<string, any>) => EventData<any>;
+    /** Pure fold step: (state, event) → state. Idempotent by id; no
+     * Date.now/random; malformed data returns state unchanged, never throws. */
+    processor: (state: StateType, eventData: any) => StateType;
+    collapseConfig?: CollapsibleConfig;
+    triggerMeta?: TriggerMeta;
+    sideEffect?: EventSideEffect;
+    permission?: "user_exclusive";
+    conflictPolicy?: "mark" | "silent";
+}
+/**
+ * What a tool may return. MIRRORS the host's `ToolResult`
+ * (src/application-interfaces/venus-sdk.ts) exactly — the drift gate
+ * (src/lib/plugins/sdk-drift.test.ts) asserts a plugin authored against this
+ * package satisfies the platform, and this type used to be `unknown`: wider
+ * than the host's union, so `Promise<unknown>` was not assignable to
+ * `Promise<ToolResult>` and EVERY SDK-authored toolkit failed the forward
+ * assertion. A plugin author must learn the real contract here, not at
+ * install time.
+ *
+ * `{ text, images? }` is how a tool returns pictures the model can see;
+ * `imageUrls` are workspace blob URLs.
+ */
+export type ToolResult = string | {
+    text: string;
+    images?: string[];
+    imageUrls?: string[];
+};
+export interface ApplicationTools {
+    description: string;
+    parameters: z.ZodObject<Record<string, z.ZodTypeAny>>;
+    /** Server-side execution. */
+    execute: (args: Record<string, any>) => Promise<ToolResult>;
+    /** Browser-side execution (WebRTC voice etc.). REQUIRED — a tool without
+     * it type-fails the whole toolkit. */
+    onClient: (args: Record<string, any>) => void | ToolResult | Promise<void | ToolResult>;
+    background?: boolean;
+    realtimeWait?: {
+        channel: any;
+        topic: string;
+        isTerminal: (data: any) => boolean;
+        extractResult: (data: any) => string;
+    };
+}
+/** Durable-task context (Inngest under the hood). Everything you need is on
+ * ctx — a task handler imports NOTHING server-only. */
+export interface AppTaskContext<TState extends ApplicationIdentifier> {
+    identifier: ApplicationIdentifier;
+    eventData: Record<string, any>;
+    /** Inngest step API. RULE: every side effect goes inside a step.run. */
+    step: any;
+    logger: any;
+    getState(): Promise<TState>;
+    dispatchEvent(eventName: string, eventData: any): Promise<void>;
+    notify(topic: string, data: any): Promise<void>;
+}
+export interface AppTaskDefinition<TState extends ApplicationIdentifier> {
+    /** Becomes the Inngest event `<applicationType>/<taskName>`. */
+    taskName: string;
+    description?: string;
+    concurrency?: {
+        limit: number;
+        scope: "per-app" | "global";
+    };
+    handler: (ctx: AppTaskContext<TState>) => Promise<void>;
+}
+/** MIRRORS the host. What a redactor is told about who is looking. */
+export interface PublicSharingContext {
+    viewerKind: "public" | "collaborator-readonly";
+    defaultRole: string;
+    appRoles: Record<string, string> | null;
+    /** Every id this viewer has acted under (guest cookie, user id, guest ids
+     *  linked at login) — keep their own items unredacted, blank the rest. */
+    viewerIds?: string[];
+}
+export interface PublicSharingPolicy<StateType> {
+    policy?: "allowed" | "never";
+    /** Returns the FULL state shape, not a Partial — the host folds the result
+     *  as the app's state. (This mirror said `Partial<StateType>`, which is not
+     *  assignable to the host's return type: a plugin author following the SDK
+     *  would have written a redactor the platform rejects.) */
+    redactState?: (state: StateType, ctx: PublicSharingContext) => StateType;
+}
+/** MIRRORS the host's `ApplicationPort` (model/knowledge-workspace.ts). The
+ *  two loosely-typed members are platform-internal shapes a plugin never
+ *  constructs by hand; most plugins return `[]` from `getPorts`. */
+export interface ApplicationPort {
+    id: string;
+    portType: any;
+    portName: string;
+    eventName: string;
+    eventDataSchema: any;
+    eventTargets: any[];
+}
+/** MIRRORS the host. Present only when a tool runs inside an agent-builder
+ *  run; absent for chat / voice / SDK calls. */
+export interface AgentRunToolContext {
+    agentRunId: string;
+    agentBuilderNodeId: string;
+    currentAgentNodeId: string | null;
+    userId: string;
+    setWaitDirectiveCreatedThisStep: () => void;
+    isWaitDirectiveAlreadyCreatedThisStep: () => boolean;
+}
+/**
+ * THE schema — the one object a plugin's entry module exports as
+ * `pluginSchema`. Identical contract to every built-in app.
+ */
+export interface ApplicationSchema<StateType extends ApplicationIdentifier> {
+    applicationType: string;
+    description: string;
+    controlPlane?: true;
+    reactNode: ComponentType<{
+        state: StateType;
+    }>;
+    events: EventDefinition<StateType>[];
+    stateCreator: (identifier: ApplicationIdentifier, data: any) => StateType;
+    toolkitCreator: (identifier: ApplicationIdentifier, forChatId: string, eventCallback: (event: any) => void, chatMessageCallback: (message: any) => void, runCtx?: AgentRunToolContext) => Record<string, ApplicationTools>;
+    getPorts: () => ApplicationPort[];
+    tasks?: AppTaskDefinition<StateType>[];
+    channel?: (params: {
+        workspaceId: string;
+        nodeId: string;
+    }) => any;
+    getStateDescription: (applicationState: any) => string;
+    publicSharing?: PublicSharingPolicy<StateType>;
+    movable?: boolean;
+    reconstructStateFromEventLog?: boolean;
+    slimForBroadcast?: (state: StateType) => Partial<StateType> | undefined;
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+export var EventTypes;
+(function (EventTypes) {
+    EventTypes["Client"] = "Client";
+    EventTypes["Workflow"] = "Workflow";
+    EventTypes["Workspace"] = "Workspace";
+})(EventTypes || (EventTypes = {}));