effect-assistant 0.2.0 → 0.3.0

package/dist/AppEvent.d.ts

@@ -1,111 +0,0 @@
-import * as SchemaAST from "effect/SchemaAST";
-import * as Schema from "effect/Schema";
-declare namespace AppEvent_d_exports {
-  export { Any, AppEvent, EventSchema, Render, Type, make };
-}
-/**
- * Schema for one of the application's own events.
- *
- * It is a tagged struct or class (`Schema.TaggedStruct`, `Schema.TaggedClass`) that needs no
- * services.
- *
- * @category models
- * @since 0.1.0
- */
-export type EventSchema = Schema.Codec<{
-  readonly _tag: string;
-}, {
-  readonly _tag: string;
-}> & {
-  readonly fields: {
-    readonly _tag: {
-      readonly ast: SchemaAST.AST;
-    };
-  };
-};
-/**
- * Describes how the model reads an event.
- *
- * `"json"` shows the event's tag and fields as JSON. A function shows the text it returns for the
- * event.
- *
- * @category models
- * @since 0.1.0
- */
-export type Render<A> = "json" | ((event: A) => string);
-/**
- * Represents one of the application's events, registered with an assistant.
- *
- * It holds the event's schema and tag, whether storing it wakes a turn, and how the model reads
- * it. A `render` of `undefined` means the model doesn't read it.
- *
- * @category models
- * @since 0.1.0
- */
-export interface AppEvent<S extends EventSchema = EventSchema> {
-  readonly schema: S;
-  readonly tag: string;
-  readonly wakes: boolean;
-  readonly render: Render<S["Type"]> | undefined;
-}
-/**
- * Represents any registered event, for generic constraints.
- *
- * @category utility types
- * @since 0.1.0
- */
-export type Any = AppEvent<any>;
-/**
- * Extracts the type of a registered event's values.
- *
- * @category utility types
- * @since 0.1.0
- */
-export type Type<E extends Any> = E["schema"]["Type"];
-/**
- * Registers one of the application's events with an assistant.
- *
- * **Details**
- *
- * Storing the event wakes a turn only when `wakes` is `true`; it defaults to `false`. `render`
- * defaults to `"json"` for an event that wakes a turn. An event that doesn't wake a turn and has
- * no `render` isn't read by the model.
- *
- * The schema must be a tagged struct or class whose `_tag` is a string literal; `make` throws
- * otherwise.
- *
- * **Example** (Registering an event that wakes a turn)
- *
- * ```ts
- * import { AppEvent, Assistant, InputId } from "effect-assistant"
- * import * as Schema from "effect/Schema"
- *
- * class OrderShipped extends Schema.TaggedClass<OrderShipped>()("OrderShipped", {
- *   id: InputId.InputId,
- *   orderId: Schema.String,
- *   carrier: Schema.String
- * }) {}
- *
- * export const MyAssistant = Assistant.make("my-assistant", {
- *   events: [
- *     AppEvent.make(OrderShipped, {
- *       wakes: true,
- *       render: (shipped) =>
- *         `Order ${shipped.orderId} shipped with ${shipped.carrier}. Tell the user if it matters.`
- *     })
- *   ]
- * })
- * ```
- *
- * @category constructors
- * @since 0.1.0
- */
-export declare const make: <S extends EventSchema>(schema: S, options?: {
-  /** Whether storing it starts a turn, like a user's message. Default false. */
-  readonly wakes?: boolean | undefined;
-  /** How the model reads it in its history. */
-  readonly render?: Render<S["Type"]> | undefined;
-}) => AppEvent<S>;
-//#endregion
-export { AppEvent_d_exports };
-//# sourceMappingURL=AppEvent.d.ts.map

package/dist/AppEvent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AppEvent.d.ts","names":[],"sources":["../src/AppEvent.ts"],"mappings":";;;;;;;;;;;;;;YAuBY,cAAc,OAAO;WAAiB;;WAA2B;;WAClE;aAAmB;eAAiB,KAAK,UAAU;;;;;;;;;;;;;YAYlD,OAAO,gBAAgB,OAAO;;;;;;;;;;iBAWzB,SAAS,UAAU,cAAc;WACvC,QAAQ;WACR;WACA;WACA,QAAQ,OAAO;;;;;;;;YASd,MAAM;;;;;;;YAQN,KAAK,UAAU,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgDrB,OAAQ,UAAU,aAAW,QAChC,GAAC;;WAGE;;WAEA,SAAS,OAAO;MAE1B,SAAS"}

package/dist/AppEvent.js

@@ -1,71 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import * as Predicate from "effect/Predicate";
-import * as SchemaAST from "effect/SchemaAST";
-//#region src/AppEvent.ts
-/**
-* Registers an application's own events with an assistant.
-*
-* An app event is a tagged schema for something the application reports into a chat, such as a
-* workflow's progress, a webhook, a summary for compaction, or the draft the user opened.
-* {@link make} registers one with two choices: whether storing it wakes a turn (`wakes`), and
-* how the model reads it (`render`).
-*
-* @since 0.1.0
-*/
-var AppEvent_exports = /* @__PURE__ */ __exportAll({ make: () => make });
-const tagOf = (schema) => {
-	const ast = schema.fields._tag.ast;
-	if (SchemaAST.isLiteral(ast) && Predicate.isString(ast.literal)) return ast.literal;
-	throw new Error("An app event is a tagged struct or class.");
-};
-/**
-* Registers one of the application's events with an assistant.
-*
-* **Details**
-*
-* Storing the event wakes a turn only when `wakes` is `true`; it defaults to `false`. `render`
-* defaults to `"json"` for an event that wakes a turn. An event that doesn't wake a turn and has
-* no `render` isn't read by the model.
-*
-* The schema must be a tagged struct or class whose `_tag` is a string literal; `make` throws
-* otherwise.
-*
-* **Example** (Registering an event that wakes a turn)
-*
-* ```ts
-* import { AppEvent, Assistant, InputId } from "effect-assistant"
-* import * as Schema from "effect/Schema"
-*
-* class OrderShipped extends Schema.TaggedClass<OrderShipped>()("OrderShipped", {
-*   id: InputId.InputId,
-*   orderId: Schema.String,
-*   carrier: Schema.String
-* }) {}
-*
-* export const MyAssistant = Assistant.make("my-assistant", {
-*   events: [
-*     AppEvent.make(OrderShipped, {
-*       wakes: true,
-*       render: (shipped) =>
-*         `Order ${shipped.orderId} shipped with ${shipped.carrier}. Tell the user if it matters.`
-*     })
-*   ]
-* })
-* ```
-*
-* @category constructors
-* @since 0.1.0
-*/
-const make = (schema, options) => {
-	const wakes = options?.wakes ?? false;
-	return {
-		schema,
-		tag: tagOf(schema),
-		wakes,
-		render: options?.render ?? (wakes ? "json" : void 0)
-	};
-};
-//#endregion
-export { AppEvent_exports, make };
-
-//# sourceMappingURL=AppEvent.js.map

package/dist/AppEvent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AppEvent.js","names":[],"sources":["../src/AppEvent.ts"],"sourcesContent":["/**\n * Registers an application's own events with an assistant.\n *\n * An app event is a tagged schema for something the application reports into a chat, such as a\n * workflow's progress, a webhook, a summary for compaction, or the draft the user opened.\n * {@link make} registers one with two choices: whether storing it wakes a turn (`wakes`), and\n * how the model reads it (`render`).\n *\n * @since 0.1.0\n */\nimport * as Predicate from \"effect/Predicate\"\nimport type * as Schema from \"effect/Schema\"\nimport * as SchemaAST from \"effect/SchemaAST\"\n\n/**\n * Schema for one of the application's own events.\n *\n * It is a tagged struct or class (`Schema.TaggedStruct`, `Schema.TaggedClass`) that needs no\n * services.\n *\n * @category models\n * @since 0.1.0\n */\nexport type EventSchema = Schema.Codec<{ readonly _tag: string }, { readonly _tag: string }> & {\n  readonly fields: { readonly _tag: { readonly ast: SchemaAST.AST } }\n}\n\n/**\n * Describes how the model reads an event.\n *\n * `\"json\"` shows the event's tag and fields as JSON. A function shows the text it returns for the\n * event.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Render<A> = \"json\" | ((event: A) => string)\n\n/**\n * Represents one of the application's events, registered with an assistant.\n *\n * It holds the event's schema and tag, whether storing it wakes a turn, and how the model reads\n * it. A `render` of `undefined` means the model doesn't read it.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface AppEvent<S extends EventSchema = EventSchema> {\n  readonly schema: S\n  readonly tag: string\n  readonly wakes: boolean\n  readonly render: Render<S[\"Type\"]> | undefined\n}\n\n/**\n * Represents any registered event, for generic constraints.\n *\n * @category utility types\n * @since 0.1.0\n */\nexport type Any = AppEvent<any>\n\n/**\n * Extracts the type of a registered event's values.\n *\n * @category utility types\n * @since 0.1.0\n */\nexport type Type<E extends Any> = E[\"schema\"][\"Type\"]\n\nconst tagOf = (schema: EventSchema): string => {\n  const ast = schema.fields._tag.ast\n\n  if (SchemaAST.isLiteral(ast) && Predicate.isString(ast.literal)) return ast.literal\n\n  throw new Error(\"An app event is a tagged struct or class.\")\n}\n\n/**\n * Registers one of the application's events with an assistant.\n *\n * **Details**\n *\n * Storing the event wakes a turn only when `wakes` is `true`; it defaults to `false`. `render`\n * defaults to `\"json\"` for an event that wakes a turn. An event that doesn't wake a turn and has\n * no `render` isn't read by the model.\n *\n * The schema must be a tagged struct or class whose `_tag` is a string literal; `make` throws\n * otherwise.\n *\n * **Example** (Registering an event that wakes a turn)\n *\n * ```ts\n * import { AppEvent, Assistant, InputId } from \"effect-assistant\"\n * import * as Schema from \"effect/Schema\"\n *\n * class OrderShipped extends Schema.TaggedClass<OrderShipped>()(\"OrderShipped\", {\n *   id: InputId.InputId,\n *   orderId: Schema.String,\n *   carrier: Schema.String\n * }) {}\n *\n * export const MyAssistant = Assistant.make(\"my-assistant\", {\n *   events: [\n *     AppEvent.make(OrderShipped, {\n *       wakes: true,\n *       render: (shipped) =>\n *         `Order ${shipped.orderId} shipped with ${shipped.carrier}. Tell the user if it matters.`\n *     })\n *   ]\n * })\n * ```\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = <S extends EventSchema>(\n  schema: S,\n  options?: {\n    /** Whether storing it starts a turn, like a user's message. Default false. */\n    readonly wakes?: boolean | undefined\n    /** How the model reads it in its history. */\n    readonly render?: Render<S[\"Type\"]> | undefined\n  }\n): AppEvent<S> => {\n  const wakes = options?.wakes ?? false\n\n  return {\n    schema,\n    tag: tagOf(schema),\n    wakes,\n    render: options?.render ?? (wakes ? \"json\" : undefined)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAsEA,MAAM,SAAS,WAAgC;CAC7C,MAAM,MAAM,OAAO,OAAO,KAAK;CAE/B,IAAI,UAAU,UAAU,GAAG,KAAK,UAAU,SAAS,IAAI,OAAO,GAAG,OAAO,IAAI;CAE5E,MAAM,IAAI,MAAM,2CAA2C;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,MAAa,QACX,QACA,YAMgB;CAChB,MAAM,QAAQ,SAAS,SAAS;CAEhC,OAAO;EACL;EACA,KAAK,MAAM,MAAM;EACjB;EACA,QAAQ,SAAS,WAAW,QAAQ,SAAS,KAAA;CAC/C;AACF"}

package/dist/ChatView.d.ts

@@ -1,408 +0,0 @@
-import { AnyEntry, AssistantEvent_d_exports } from "./AssistantEvent.js";
-import * as Schema from "effect/Schema";
-import * as Stream from "effect/Stream";
-declare namespace ChatView_d_exports {
-  export { Activity, AssistantMessage, Block, BlockStatus, Definition, Message, Options, SpecialistWorking, Update, UpdatesOptions, UserMessage, View, apply, empty, fromEntries, isIdle, updates };
-}
-/**
- * Schema for the status of a block. A block is `"open"` while it accepts an answer, `"answered"`
- * once the user has used it, and `"closed"` when it closed without an answer because the user
- * answered in words or moved on.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const BlockStatus: Schema.Literals<readonly ["open", "answered", "closed"]>;
-/**
- * The status of a block.
- *
- * @category models
- * @since 0.1.0
- */
-export type BlockStatus = typeof BlockStatus.Type;
-/**
- * Schema for a block on an assistant's message. It holds the block's kind, its props (JSON, as
- * the block's props schema encodes them), its status, and the user's answer (JSON, as the block's
- * answer schema encodes it).
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const Block: Schema.Struct<{
-  readonly kind: Schema.String;
-  readonly props: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-  readonly status: Schema.Literals<readonly ["open", "answered", "closed"]>;
-  readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-}>;
-/**
- * Represents a block on an assistant's message.
- *
- * @category models
- * @since 0.1.0
- */
-export type Block = typeof Block.Type;
-/**
- * Schema for a message the user sent. `at` is when it was stored, in epoch
- * milliseconds.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const UserMessage: Schema.TaggedStruct<"UserMessage", {
-  readonly id: Schema.brand<Schema.String, "~effect-assistant/InputId">;
-  readonly text: Schema.String;
-  readonly attachments: Schema.optional<Schema.$Array<Schema.Struct<{
-    readonly fileId: Schema.String;
-    readonly name: Schema.String;
-    readonly mediaType: Schema.String;
-    readonly size: Schema.Finite;
-  }>>>;
-  readonly at: Schema.Finite;
-}>;
-/**
- * Represents a message the user sent.
- *
- * @category models
- * @since 0.1.0
- */
-export type UserMessage = typeof UserMessage.Type;
-/**
- * Schema for a message the assistant sent the user, including its block if it has one.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const AssistantMessage: Schema.TaggedStruct<"AssistantMessage", {
-  readonly id: Schema.String;
-  readonly text: Schema.String;
-  readonly at: Schema.Finite;
-  readonly block: Schema.optional<Schema.Struct<{
-    readonly kind: Schema.String;
-    readonly props: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-    readonly status: Schema.Literals<readonly ["open", "answered", "closed"]>;
-    readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-  }>>;
-}>;
-/**
- * Represents a message the assistant sent the user.
- *
- * @category models
- * @since 0.1.0
- */
-export type AssistantMessage = typeof AssistantMessage.Type;
-/**
- * Schema for a message in the chat, sent by either the user or the assistant.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const Message: Schema.Union<readonly [Schema.TaggedStruct<"UserMessage", {
-  readonly id: Schema.brand<Schema.String, "~effect-assistant/InputId">;
-  readonly text: Schema.String;
-  readonly attachments: Schema.optional<Schema.$Array<Schema.Struct<{
-    readonly fileId: Schema.String;
-    readonly name: Schema.String;
-    readonly mediaType: Schema.String;
-    readonly size: Schema.Finite;
-  }>>>;
-  readonly at: Schema.Finite;
-}>, Schema.TaggedStruct<"AssistantMessage", {
-  readonly id: Schema.String;
-  readonly text: Schema.String;
-  readonly at: Schema.Finite;
-  readonly block: Schema.optional<Schema.Struct<{
-    readonly kind: Schema.String;
-    readonly props: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-    readonly status: Schema.Literals<readonly ["open", "answered", "closed"]>;
-    readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-  }>>;
-}>]>;
-/**
- * Represents a message in the chat.
- *
- * @category models
- * @since 0.1.0
- */
-export type Message = typeof Message.Type;
-/**
- * Schema for a specialist that is working for the assistant. It holds the specialist's name and
- * when it started, in epoch milliseconds.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const SpecialistWorking: Schema.Struct<{
-  readonly specialist: Schema.String;
-  readonly since: Schema.Finite;
-}>;
-/**
- * Represents a specialist that is working for the assistant.
- *
- * @category models
- * @since 0.1.0
- */
-export type SpecialistWorking = typeof SpecialistWorking.Type;
-/**
- * Schema for what is working in the chat.
- *
- * `working` is true while the assistant runs a turn, or when a turn is about to start for
- * something that arrived. `specialists` lists the specialists that are working. When the chat is
- * idle, nothing is working, even if a workflow is waiting on a timer or on the user.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const Activity: Schema.Struct<{
-  readonly working: Schema.Boolean;
-  readonly specialists: Schema.$Array<Schema.Struct<{
-    readonly specialist: Schema.String;
-    readonly since: Schema.Finite;
-  }>>;
-}>;
-/**
- * Represents what is working in the chat.
- *
- * @category models
- * @since 0.1.0
- */
-export type Activity = typeof Activity.Type;
-/**
- * Schema for a chat as its user sees it. It holds the chat's messages, what is working in it,
- * whether the last turn failed, and whether the chat was deleted. `seq` is the position in the
- * chat's log that the view is up to.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const View: Schema.Struct<{
-  readonly seq: Schema.Int;
-  readonly messages: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"UserMessage", {
-    readonly id: Schema.brand<Schema.String, "~effect-assistant/InputId">;
-    readonly text: Schema.String;
-    readonly attachments: Schema.optional<Schema.$Array<Schema.Struct<{
-      readonly fileId: Schema.String;
-      readonly name: Schema.String;
-      readonly mediaType: Schema.String;
-      readonly size: Schema.Finite;
-    }>>>;
-    readonly at: Schema.Finite;
-  }>, Schema.TaggedStruct<"AssistantMessage", {
-    readonly id: Schema.String;
-    readonly text: Schema.String;
-    readonly at: Schema.Finite;
-    readonly block: Schema.optional<Schema.Struct<{
-      readonly kind: Schema.String;
-      readonly props: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-      readonly status: Schema.Literals<readonly ["open", "answered", "closed"]>;
-      readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    }>>;
-  }>]>>;
-  readonly activity: Schema.Struct<{
-    readonly working: Schema.Boolean;
-    readonly specialists: Schema.$Array<Schema.Struct<{
-      readonly specialist: Schema.String;
-      readonly since: Schema.Finite;
-    }>>;
-  }>;
-  /** Whether the last turn failed with no message after it. */
-  readonly failed: Schema.Boolean;
-  /** Whether the chat was deleted. A deleted chat accepts nothing more, and its stream ends. */
-  readonly deleted: Schema.Boolean;
-}>;
-/**
- * Represents a chat as its user sees it.
- *
- * @category models
- * @since 0.1.0
- */
-export type View = typeof View.Type;
-/**
- * Schema for a change to a chat's view.
- *
- * An update holds each message that is new or changed (for example, a block answered or
- * closed), in full. It also holds the current activity, whether the last turn failed,
- * and whether the chat was deleted. `seq` is the position in the chat's log that the update is up
- * to.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const Update: Schema.Struct<{
-  readonly seq: Schema.Int;
-  readonly messages: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"UserMessage", {
-    readonly id: Schema.brand<Schema.String, "~effect-assistant/InputId">;
-    readonly text: Schema.String;
-    readonly attachments: Schema.optional<Schema.$Array<Schema.Struct<{
-      readonly fileId: Schema.String;
-      readonly name: Schema.String;
-      readonly mediaType: Schema.String;
-      readonly size: Schema.Finite;
-    }>>>;
-    readonly at: Schema.Finite;
-  }>, Schema.TaggedStruct<"AssistantMessage", {
-    readonly id: Schema.String;
-    readonly text: Schema.String;
-    readonly at: Schema.Finite;
-    readonly block: Schema.optional<Schema.Struct<{
-      readonly kind: Schema.String;
-      readonly props: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-      readonly status: Schema.Literals<readonly ["open", "answered", "closed"]>;
-      readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    }>>;
-  }>]>>;
-  readonly activity: Schema.Struct<{
-    readonly working: Schema.Boolean;
-    readonly specialists: Schema.$Array<Schema.Struct<{
-      readonly specialist: Schema.String;
-      readonly since: Schema.Finite;
-    }>>;
-  }>;
-  readonly failed: Schema.Boolean;
-  readonly deleted: Schema.Boolean;
-}>;
-/**
- * Represents a change to a chat's view.
- *
- * @category models
- * @since 0.1.0
- */
-export type Update = typeof Update.Type;
-/**
- * The view of a chat before anything has happened in it, with no messages and nothing working.
- * Use it as the starting point when folding updates with {@link apply}.
- *
- * @category constructors
- * @since 0.1.0
- */
-export declare const empty: View;
-/**
- * Returns the view after applying an update.
- *
- * **Details**
- *
- * Each message in the update replaces the message with the same id, in place, and new messages
- * are added after the rest. The update's activity, `failed`, and `deleted` replace the view's.
- * Applying an update twice changes nothing, so a client that resubscribes from the start can fold
- * again and get the same view.
- *
- * @category combinators
- * @since 0.1.0
- */
-export declare const apply: (view: View, update: Update) => View;
-/**
- * Returns whether nothing is working in the chat: no turn is running or about to start, and no
- * specialist is working.
- *
- * @category guards
- * @since 0.1.0
- */
-export declare const isIdle: (view: View) => boolean;
-/**
- * Represents the options for building a view from a chat's log.
- *
- * @category models
- * @since 0.1.0
- */
-export interface Options {
-  /**
-   * The tags of the app's events that wake a turn. After such an event, the view shows a turn as
-   * about to start. Defaults to none.
-   */
-  readonly wakes?: ReadonlySet<string> | undefined;
-}
-/**
- * Returns a chat's view, built from the entries of its log.
- *
- * **When to use**
- *
- * Use it in server-side code, for example to return a whole chat at once. A client gets the view
- * as a stream from {@link updates} instead.
- *
- * **Example** (Building a chat's view from its log)
- *
- * ```ts
- * import { type ChatId, ChatLog, ChatView } from "effect-assistant"
- * import * as Effect from "effect/Effect"
- *
- * const viewOf = (chatId: ChatId.ChatId) =>
- *   ChatLog.ChatLog.use((log) => log.read(chatId)).pipe(
- *     Effect.map((entries) => ChatView.fromEntries(entries))
- *   )
- * ```
- *
- * @see {@link updates} for a stream of changes instead of a whole view
- *
- * @category constructors
- * @since 0.1.0
- */
-export declare const fromEntries: (entries: ReadonlyArray<AnyEntry>, options?: Options) => View;
-/**
- * Represents an assistant's definition as {@link updates} reads it: the app's events it
- * registered, and whether each one wakes a turn. An assistant made with `Assistant.make` fits it.
- *
- * @category models
- * @since 0.1.0
- */
-export interface Definition {
-  readonly events: ReadonlyArray<{
-    readonly tag: string;
-    readonly wakes: boolean;
-  }>;
-}
-/**
- * Represents the options accepted by {@link updates}.
- *
- * @category models
- * @since 0.1.0
- */
-export interface UpdatesOptions {
-  /**
-   * The `seq` up to which the client already has the view. The result contains only the updates
-   * after it. Defaults to `0`, every update.
-   */
-  readonly after?: number | undefined;
-}
-/**
- * Returns the stream of view updates that a chat's entries produce, for a chat client.
- *
- * **Details**
- *
- * The entries must stream from the start of the chat's log, as `assistant.subscribe(chatId)` does
- * without `after`. The fold reads every entry, because a message's view depends on earlier
- * entries: a block is answered or closed later. `after` only skips
- * emitting the updates up to that `seq`, so a client that has the view up to a `seq` receives only
- * what changed since. Pass `after` here, not to `subscribe`: a subscription that starts after a
- * `seq` gives the fold an incomplete log, and the updates it produces are wrong.
- *
- * The definition tells the fold which of the app's events wake a turn, so the view shows a turn as
- * about to start after one. Each chunk of entries becomes one update; the stored entries, for
- * example, arrive as one chunk.
- *
- * **Example** (Streaming a chat's view to a client)
- *
- * ```ts
- * import { Assistant, type ChatId, ChatView } from "effect-assistant"
- * import * as Stream from "effect/Stream"
- *
- * const MyAssistant = Assistant.make("my-assistant")
- *
- * const watch = (chatId: ChatId.ChatId, after: number) =>
- *   Stream.unwrap(
- *     MyAssistant.useSync((assistant) =>
- *       assistant.subscribe(chatId).pipe(ChatView.updates(MyAssistant, { after }))
- *     )
- *   )
- * ```
- *
- * @see {@link apply} for folding the updates into a view on the client
- *
- * @category utils
- * @since 0.1.0
- */
-export declare const updates: {
-  (definition: Definition, options?: UpdatesOptions): <E, R>(entries: Stream.Stream<AnyEntry, E, R>) => Stream.Stream<Update, E, R>;
-  <E, R>(entries: Stream.Stream<AnyEntry, E, R>, definition: Definition, options?: UpdatesOptions): Stream.Stream<Update, E, R>;
-};
-//#endregion
-export { ChatView_d_exports };
-//# sourceMappingURL=ChatView.d.ts.map

package/dist/ChatView.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ChatView.d.ts","names":[],"sources":["../src/ChatView.ts"],"mappings":";;;;;;;;;;;;;;qBA+Ba,aAAW,OAAA;;;;;;;YAQZ,qBAAqB,YAAY;;;;;;;;;qBAUhC,OAAK,OAAA;;;;;;;;;;;;YAaN,eAAe,MAAM;;;;;;;;qBASpB,aAAW,OAAA;;;;;;;;;;;;;;;;;YAaZ,qBAAqB,YAAY;;;;;;;qBAQhC,kBAAgB,OAAA;;;;;;;;;;;;;;;;;YAajB,0BAA0B,iBAAiB;;;;;;;qBAQ1C,SAAO,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;YAQR,iBAAiB,QAAQ;;;;;;;;qBASxB,mBAAiB,OAAA;;;;;;;;;;YAWlB,2BAA2B,kBAAkB;;;;;;;;;;;qBAY5C,UAAQ,OAAA;;;;;;;;;;;;;YAWT,kBAAkB,SAAS;;;;;;;;;qBAU1B,MAAI,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAgBL,cAAc,KAAK;;;;;;;;;;;;qBAalB,QAAM,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAcP,gBAAgB,OAAO;;;;;;;;qBAStB,OAAO;;;;;;;;;;;;;;qBAqBP,QAAK,MAAU,MAAI,QAAU,WAAS;;;;;;;;qBAuBtC,SAAM,MAAU;;;;;;;iBAQZ;;;;;WAKN,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4BN,cAAW,SAAa,cAAc,WAAwB,UAAY,YAAU;;;;;;;;iBAoLhF;WACN,QAAQ;aAAyB;aAAsB;;;;;;;;;iBASjD;;;;;WAKN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2CE;GAET,YAAY,YACZ,UAAU,kBACR,GAAG,GAAG,SAAS,OAAO,OAAO,UAAyB,GAAG,OAAO,OAAO,OAAO,QAAQ,GAAG;GAC5F,GAAG,GACF,SAAS,OAAO,OAAO,UAAyB,GAAG,IACnD,YAAY,YACZ,UAAU,iBACT,OAAO,OAAO,QAAQ,GAAG"}