foldkit-primitives 0.15.3 → 0.16.0

package/dist/net/index.d.mts

@@ -1,348 +0,0 @@
-import { Option, Queue, Schema, Stream } from "effect";
-import { Bundle } from "foldkit-bundle";
-import * as ManagedResource from "foldkit/managedResource";
-import { Command } from "foldkit/command";
-import * as Update from "foldkit/update";
-//#region src/net/broadcast.d.ts
-export declare const BroadcastMessage: import("foldkit/message").MessageUnion<{
-  /** Notifies without storing: project the payload into your own field to keep it. */
-  readonly Received: {
-    data: Schema.Unknown;
-  };
-  readonly Posted: {};
-  readonly BroadcastFailed: {
-    message: Schema.String;
-  };
-}>;
-export type BroadcastMessage = typeof BroadcastMessage.Type;
-/** The slice of a BroadcastChannel this module needs; satisfied by the platform class. */
-export interface BroadcastChannelHandle {
-  postMessage(data: unknown): void;
-  close(): void;
-  onmessage: ((event: {
-    readonly data: unknown;
-  }) => void) | null;
-}
-type ChannelFactory = (name: string) => BroadcastChannelHandle;
-/**
- * Every post to `name` from another channel, as Messages. Without a
- * BroadcastChannel API the stream is empty instead of throwing; closing the
- * stream closes the channel.
- */
-export declare const broadcastMessages: (name: string,
-/** Read lazily so tests can substitute a double, like the SSE bundle. */
-create?: ChannelFactory | undefined) => Stream.Stream<BroadcastMessage>;
-/**
- * Posts one message to `name`. Opens a channel, posts, and closes it: the
- * send is one-shot, so it is a Command, not a resource. Without a
- * BroadcastChannel API — or when the post throws — it yields
- * `BroadcastFailed` instead of throwing.
- */
-export declare const postBroadcast: (name: string, data: unknown, create?: ChannelFactory | undefined) => Command<BroadcastMessage, never, never>;
-//#endregion
-//#region src/net/online.d.ts
-export declare const OnlineModel: Schema.Struct<{
-  readonly online: Schema.Boolean;
-}>;
-export type OnlineModel = typeof OnlineModel.Type;
-export declare const OnlineMessage: import("foldkit/message").MessageUnion<{
-  readonly Changed: {
-    online: Schema.Boolean;
-  };
-}>;
-export type OnlineMessage = typeof OnlineMessage.Type;
-/**
- * Online presence as a bundle: `online` in the Model, kept current by the
- * window's online/offline events. The browser reports facts; the Model owns
- * the state, so presence replays like any other transition.
- */
-export declare const Online: Bundle.Bundle<"Online", void, {
-  readonly online: boolean;
-}, {
-  readonly _tag: "Changed";
-  readonly online: boolean;
-}, never, never, never, void, {}, {}>;
-//#endregion
-//#region src/net/sharedHost.d.ts
-/** One conversation a page opened: its port, and a signal that aborts once the page is gone. */
-export interface Conversation {
-  readonly port: MessagePort;
-  readonly signal: AbortSignal;
-}
-/** What the host does with each conversation, told what the page opened it for. */
-export type ConversationHandler<Opening> = (opening: Opening, conversation: Conversation) => void;
-/** Starts the host, once, the first time a conversation needs it. */
-export type StartHost<Opening> = () => ConversationHandler<Opening> | Promise<ConversationHandler<Opening>>;
-/** Where `SharedHost` runs the host: in a SharedWorker, or in the page when there is none. */
-export interface SharedHostOptions<Opening> {
-  /**
-   * The SharedWorker whose entry calls `serve`. Constructed by the
-   * application, since a bundler finds a worker only in a literal
-   * `new SharedWorker(new URL('./worker.ts', import.meta.url), …)`.
-   */
-  readonly worker: () => {
-    readonly port: MessagePort;
-  };
-  /** The host, for a browser without SharedWorker: started in the top document. */
-  readonly inPage: StartHost<Opening>;
-}
-/** A page's way to the host. */
-export interface SharedHostConnection<Opening> {
-  /** Opens a conversation for `opening`, returning the page's end of it. */
-  readonly open: (opening: Opening) => MessagePort;
-}
-export interface SharedHost<Opening> {
-  readonly name: string;
-  /** A SharedWorker's entry: hands the host every conversation a page opens. */
-  readonly serve: (start: StartHost<Opening>) => void;
-  /**
-   * A page's connection: through the SharedWorker, or, without one, to the
-   * host in the top document. Call it in the top document too when that
-   * document frames the pages, so that it is the one the frames meet.
-   */
-  readonly connect: (options: SharedHostOptions<Opening>) => SharedHostConnection<Opening>;
-}
-/**
- * A shared host: its `name`, which keeps two on one origin apart, and
- * the schema of what opens a conversation, which the host decodes before
- * anything else, ignoring a message that does not decode.
- */
-declare const define: <Opening, Encoded>(options: {
-  readonly name: string;
-  readonly opening: Schema.Codec<Opening, Encoded, never, never>;
-}) => SharedHost<Opening>;
-/**
- * One server in the browser for many documents: every tab and frame of an
- * application meets the same host. A page opens conversations, each a
- * `MessagePort` with a decoded opening that says what it is for; the host, in
- * a SharedWorker shared by every tab, or in the top document where there is no
- * SharedWorker, is handed each one with a signal that aborts when the page
- * that opened it is gone.
- *
- * It owns the host's lifetime and the routing of conversations, nothing
- * spoken over them: Sync's `portSocket` and Remote's `port` do that.
- */
-export declare const SharedHost: {
-  define: typeof define;
-};
-//#endregion
-//#region src/net/sse.d.ts
-/** The slice of an EventSource the bundle needs; satisfied by the platform class. */
-export interface SourceHandle {
-  readonly readyState: number;
-  close(): void;
-  onopen: ((event: any) => void) | null;
-  onmessage: ((event: any) => void) | null;
-  onerror: ((event: any) => void) | null;
-}
-export declare const SseModel: Schema.Struct<{
-  readonly url: Schema.String;
-  readonly status: Schema.Literals<readonly ["closed", "connecting", "open"]>;
-  readonly lastError: Schema.NullOr<Schema.String>;
-}>;
-export type SseModel = typeof SseModel.Type;
-export declare const SseMessage: import("foldkit/message").MessageUnion<{
-  readonly Connecting: {};
-  readonly Opened: {};
-  /** Notifies without storing: project the payload into your own field to keep it. */
-  readonly Received: {
-    data: Schema.String;
-  };
-  readonly Closed: {};
-  readonly Failed: {
-    message: Schema.String;
-  };
-}>;
-export type SseMessage = typeof SseMessage.Type;
-/**
- * What the reader sees: the stream's state, or its error. A page derives
- * this instead of keeping its own connection state machine. `lastError`
- * carries the stored failure text: the runtime error sentence (`event stream
- * error for …`) or the acquire error's own message.
- */
-export declare const SseView: import("foldkit/schema").TaggedUnion<{
-  readonly Disconnected: {};
-  readonly Connecting: {};
-  readonly Connected: {};
-  readonly Error: {
-    error: Schema.String;
-  };
-}>;
-export type SseView = typeof SseView.Type;
-/**
- * Whether the stream is live: open with no error outstanding. The browser
- * reconnects a dropped stream itself; a `Failed` only records the error.
- */
-export declare const isLive: (model: SseModel) => boolean;
-/**
- * The view of a stream, and whether its page still wants it. An error stands
- * until the page stops wanting the stream; a retry still waiting for its
- * stream reads as connecting, so it answers at once.
- */
-export declare const viewOfSse: (model: SseModel, wanted: boolean) => SseView;
-/** The registry value behind the source tag: the live source and its incoming queue. */
-export interface AcquiredSource {
-  readonly source: SourceHandle;
-  readonly events: Queue.Queue<SseMessage>;
-}
-/** The live stream, for the incoming subscription. One assembly holds one. */
-export declare const Source: ManagedResource.ManagedResource<AcquiredSource, ManagedResource.ManagedResourceService<"sse">>;
-/** The source service a placed SSE stream requires. */
-export type SourceService = ManagedResource.ServiceOf<typeof Source>;
-/**
- * Server-sent events as a bundle: connection lifecycle in the Model, the
- * event stream through one Managed Resource. One-directional, so there is no
- * send: the server speaks, the Model listens. The browser reconnects dropped
- * streams itself; a Failed only records the error.
- */
-export declare const sse: <const Name extends string>(config: {
-  readonly name: Name;
-  /** Defaults to the platform EventSource, read lazily so tests can substitute a double. */
-  readonly createSource?: ((url: string) => SourceHandle) | undefined;
-}) => Bundle.Bundle<Name, {
-  readonly url: string;
-}, {
-  readonly url: string;
-  readonly status: "closed" | "connecting" | "open";
-  readonly lastError: string | null;
-}, {
-  readonly _tag: "Connecting";
-} | {
-  readonly _tag: "Closed";
-} | {
-  readonly _tag: "Failed";
-  readonly message: string;
-} | {
-  readonly _tag: "Opened";
-} | {
-  readonly _tag: "Received";
-  readonly data: string;
-}, never, ManagedResource.ManagedResourceService<"sse">, ManagedResource.ManagedResourceService<"sse">, void, Readonly<{
-  source: ManagedResource.Entry<SseModel, SseMessage, Option.Option<string>, AcquiredSource, SourceService, () => SseMessage>;
-}>, {}>;
-//#endregion
-//#region src/net/websocket.d.ts
-/** The slice of a WebSocket the bundle needs; satisfied by the platform socket and test doubles. Handler events are `any`: the DOM and `ws` type them differently, and only `data` is read. */
-export interface SocketHandle {
-  readonly readyState: number;
-  send(data: string): void;
-  close(): void;
-  onopen: ((event: any) => void) | null;
-  onmessage: ((event: any) => void) | null;
-  onclose: ((event: any) => void) | null;
-  onerror: ((event: any) => void) | null;
-}
-export declare const WebSocketModel: Schema.Struct<{
-  readonly url: Schema.String;
-  readonly status: Schema.Literals<readonly ["closed", "connecting", "open"]>;
-  readonly lastError: Schema.NullOr<Schema.String>;
-  /** Whether this connection attempt ever reached open; reset on Connecting. */
-  readonly opened: Schema.Boolean;
-}>;
-export type WebSocketModel = typeof WebSocketModel.Type;
-export declare const WebSocketMessage: import("foldkit/message").MessageUnion<{
-  readonly Connecting: {};
-  readonly Opened: {};
-  /** Notifies without storing: project the payload into your own field to keep it. */
-  readonly Received: {
-    data: Schema.String;
-  };
-  readonly Closed: {};
-  readonly Failed: {
-    message: Schema.String;
-  };
-  readonly SendFailed: {
-    message: Schema.String;
-  };
-  /** Acknowledges dispatch of `data`, not its delivery; update ignores it. */
-  readonly Sent: {
-    data: Schema.String;
-  };
-  /** The socket was still connecting when `connectTimeoutMs` ran out, and was closed. */
-  readonly TimedOut: {};
-}>;
-export type WebSocketMessage = typeof WebSocketMessage.Type;
-/** The registry value behind the socket tag: the live socket and its incoming queue. */
-export interface Acquired {
-  readonly socket: SocketHandle;
-  readonly events: Queue.Queue<WebSocketMessage>;
-}
-/**
- * What the reader sees: the socket's state, or its error. A page derives
- * this instead of keeping its own connection state machine. `lastError` is
- * already worded for the reader (`Failed to connect to WebSocket`, never the
- * socket's own text, which error handling drops in favor of the sentence).
- */
-export declare const SocketView: import("foldkit/schema").TaggedUnion<{
-  readonly Disconnected: {};
-  readonly Connecting: {};
-  readonly Connected: {};
-  readonly Error: {
-    error: Schema.String;
-  };
-}>;
-export type SocketView = typeof SocketView.Type;
-/**
- * Whether the socket is usable: open with no error outstanding. Gates sends
- * and received frames.
- */
-export declare const isOpen: (model: WebSocketModel) => boolean;
-/**
- * The view of a socket, and whether its page still wants it. An error stands
- * until the page stops wanting the socket; a retry still waiting for its
- * socket reads as connecting, so it answers at once. An error on an open
- * socket always reads as an error.
- */
-export declare const viewOf: (model: WebSocketModel, wanted: boolean) => SocketView;
-/** The live connection, for `send` and the incoming stream. One assembly holds one. */
-export declare const Socket: ManagedResource.ManagedResource<Acquired, ManagedResource.ManagedResourceService<"websocket">>;
-/** The socket service a placed WebSocket's streams and send commands require. */
-export type SocketService = ManagedResource.ServiceOf<typeof Socket>;
-/**
- * A WebSocket as a bundle: connection lifecycle in the Model, full duplex
- * through one Managed Resource. The resource owns the socket; a `send`
- * helper writes through its tag service (lifted to the parent like every
- * helper); a subscription stream reads incoming messages through the same
- * tag. No hidden hub: everything the bundle touches is the Model, the
- * resource registry, or a Message.
- */
-export declare const websocket: <const Name extends string>(config: {
-  readonly name: Name;
-  /** Defaults to the platform WebSocket, read lazily so tests can substitute a double. */
-  readonly createSocket?: ((url: string) => SocketHandle) | undefined;
-}) => Bundle.Bundle<Name, {
-  readonly url: string;
-  readonly connectTimeoutMs?: number | undefined;
-}, {
-  readonly url: string;
-  readonly status: "closed" | "connecting" | "open";
-  readonly lastError: string | null;
-  readonly opened: boolean;
-}, {
-  readonly _tag: "Connecting";
-} | {
-  readonly _tag: "Closed";
-} | {
-  readonly _tag: "Failed";
-  readonly message: string;
-} | {
-  readonly _tag: "Opened";
-} | {
-  readonly _tag: "Received";
-  readonly data: string;
-} | {
-  readonly _tag: "SendFailed";
-  readonly message: string;
-} | {
-  readonly _tag: "Sent";
-  readonly data: string;
-} | {
-  readonly _tag: "TimedOut";
-}, never, ManagedResource.ManagedResourceService<"websocket">, ManagedResource.ManagedResourceService<"websocket">, void, Readonly<{
-  socket: ManagedResource.Entry<WebSocketModel, WebSocketMessage, Option.Option<string>, Acquired, SocketService, () => WebSocketMessage>;
-}>, Readonly<{
-  send: (model: WebSocketModel, data: string) => Update.ReturnWithOutMessage<WebSocketModel, WebSocketMessage, never, SocketService>;
-}>>;
-//#endregion
-export {};
-//# sourceMappingURL=index.d.mts.map

package/dist/net/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/net/broadcast.ts","../../src/net/online.ts","../../src/net/sharedHost.ts","../../src/net/sse.ts","../../src/net/websocket.ts"],"mappings":";;;;;;qBAaa,4CAAgB;;;IAEf,MAAI,OAAA;;;;IAEG,SAAO,OAAA;;;YAEhB,0BAA0B,iBAAiB;;iBAGtC;EACf,YAAY;EACZ;EACA,aAAa;aAAkB;;;KAG5B,kBAAkB,iBAAiB;;;;;;qBAmB3B,oBAAiB;;AAGnB,SAAA,+BACR,OAAO,OAAO;;;;;;;qBAyBJ,gBAAa,cACZ,eACC,SACJ,+BACR,QAAQ;;;qBC3EE,aAAW,OAAA;mBAAX,OAAA;;YACD,qBAAqB,YAAY;qBAEhC,yCAAa;;IAAmC,QAAM,OAAA;;;YACvD,uBAAuB,cAAc;;;;;;qBAuBpC,QAAM,OAAA;;;;;;;;;iBC7BF;WACN,MAAM;WACN,QAAQ;;;YAIP,oBAAoB,YAAY,SAAS,SAAS,cAAc;;YAGhE,UAAU,iBAClB,oBAAoB,WACpB,QAAQ,oBAAoB;;iBAGf,kBAAkB;;;;;;WAMxB;aAAyB,MAAM;;;WAE/B,QAAQ,UAAU;;;iBAIZ,qBAAqB;;WAE3B,OAAO,SAAS,YAAY;;iBAGtB,WAAW;WACjB;;WAEA,QAAQ,OAAO,UAAU;;;;;;WAMzB,UAAU,SAAS,kBAAkB,aAAa,qBAAqB;;;;;;;cAQ5E,SAAU,SAAS,SAAO;WACrB;WACA,SAAS,OAAO,MAAM,SAAS;MACtC,WAAW;;;;;;;;;;;;qBA4IF;iBAAA;;;;;iBCxLI;WACN;EACT;EACA,UAAU;EACV,aAAa;EACb,WAAW;;qBAGA,UAAQ,OAAA;;;;;YAKT,kBAAkB,SAAS;qBAE1B,sCAAU;;;;;IAIT,MAAI,OAAA;;;;IAEN,SAAO,OAAA;;;YAEP,oBAAoB,WAAW;;;;;;;qBAQ9B,kCAAO;;;;;IAIT,OAAK,OAAA;;;YAEJ,iBAAiB,QAAQ;;;;;qBAMxB,SAAM,OAAW;;;;;;qBAQjB,YAAS,OAAW,UAAQ,oBAAoB;;iBAW5C;WACN,QAAQ;WACR,QAAQ,MAAM,MAAM;;;qBAIlB,QAAM,gBAAA,gBAAA,gBAAA,gBAAA;;YAGP,gBAAgB,gBAAgB,iBAAiB;;;;;;;qBAsBhD,YAAa,qBAAmB;WAClC,MAAM;;WAEN,iBAAiB,gBAAgB;MAC3C,OAAA,OAAA;WAOmB;;;;;;;;;;;;;;;;;;EA9BV,QAAA,gBAAgB,MACtB,UACA,YACA,OAAO,gBACP,gBACA,qBACM;;;;;iBChFO;WACN;EACT,KAAK;EACL;EACA,UAAU;EACV,aAAa;EACb,WAAW;EACX,WAAW;;qBAGA,gBAAc,OAAA;;;;;;;YAOf,wBAAwB,eAAe;qBAEtC,4CAAgB;;;;;IAIf,MAAI,OAAA;;;;IAEN,SAAO,OAAA;;;IACH,SAAO,OAAA;;;;IAEb,MAAI,OAAA;;;;;YAIF,0BAA0B,iBAAiB;;iBAGtC;WACN,QAAQ;WACR,QAAQ,MAAM,MAAM;;;;;;;;qBASlB,qCAAU;;;;;IAIZ,OAAK,OAAA;;;YAEJ,oBAAoB,WAAW;;;;;qBAM9B,SAAM,OAAW;;;;;;;qBASjB,SAAM,OAAW,gBAAc,oBAAoB;;qBAWnD,QAAM,gBAAA,gBAAA,UAAA,gBAAA;;YAGP,gBAAgB,gBAAgB,iBAAiB;;;;;;;;;qBAiDhD,kBAAmB,qBAAmB;WACxC,MAAM;;WAEN,iBAAiB,gBAAgB;MAC3C,OAAA,OAAA;WAOmB;WAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;EAzD9C,QAAA,gBAAgB,MACtB,gBACA,kBACA,OAAO,gBACP,UACA,qBACM;;EAKF,OACJ,OAAO,gBACP,iBACG,OAAO,qBAAqB,gBAAgB,yBAAyB"}