@marimo-team/frontend 0.25.3-dev40 → 0.25.3-dev44

package/src/core/host/resources/resource.ts

@@ -1,47 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import type * as Protocol from "../protocol";
-
-/**
- * Events the stream handles itself.
- *
- * They identify the notebook, discard state, or carry a native
- * notification. Resources do not receive them.
- */
-type StreamEventName = "reset" | "notebook" | "notebook.removed" | "marimo";
-
-/** Events a resource may handle. `ready` marks the end of the snapshot. */
-export type ResourceEvent = Exclude<
-  Protocol.EventOutput,
-  { event: StreamEventName }
->;
-
-/** What a handler may know about the stream beyond the event. */
-export interface HandlerContext {
-  /** `snapshot` until `ready` arrives and `live` after it. */
-  readonly phase: "snapshot" | "live";
-}
-
-/**
- * A pure handler for each event the resource reads.
- *
- * A handler returns `state` when the event does not apply to it.
- */
-type EventHandlers<State> = {
-  readonly [Name in ResourceEvent["event"]]?: (
-    state: State,
-    event: Extract<ResourceEvent, { event: Name }>,
-    context: HandlerContext,
-  ) => State;
-};
-
-/**
- * One kind of object assembled from its events.
- *
- * The stream returns a resource to `initial` on `reset` and when the
- * notebook is removed.
- */
-export interface Resource<State> {
-  readonly initial: State;
-  readonly on: EventHandlers<State>;
-}

package/src/core/host/stream.ts

@@ -1,211 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import type { NotebookEvent } from "./events";
-import type * as Protocol from "./protocol";
-import type {
-  HandlerContext,
-  Resource,
-  ResourceEvent,
-} from "./resources/resource";
-
-/** A resource for each entry of a state map under the same name. */
-type Resources<States> = {
-  readonly [Name in keyof States]: Resource<States[Name]>;
-};
-
-/**
- * The state of one notebook stream.
- *
- * Holds the phase, the notebook identity, the resume cursor, and the state
- * of each resource.
- */
-interface StreamState<States> {
-  readonly phase: HandlerContext["phase"];
-  /**
-   * The notebook the stream describes.
-   *
-   * Retained across `reset`.
-   */
-  readonly notebookId: Protocol.NotebookIdOutput | null;
-  /**
-   * The id of the last live event.
-   *
-   * Null before `ready` and after `reset`.
-   */
-  readonly cursor: string | null;
-  /** The state of each resource by name. */
-  readonly resources: States;
-}
-
-/** A reducer over the events of one notebook stream. */
-interface Stream<States> {
-  readonly initial: StreamState<States>;
-  /**
-   * Apply one event.
-   *
-   * Throws on a live event without a cursor or on an object from another
-   * notebook.
-   */
-  reduce(state: StreamState<States>, event: NotebookEvent): StreamState<States>;
-  /**
-   * The state to hold while reconnecting.
-   *
-   * A live stream keeps its state and resumes from `cursor`. An incomplete
-   * snapshot starts over.
-   */
-  resume(state: StreamState<States>): StreamState<States>;
-}
-
-/** Events that may arrive without a cursor after `ready`. */
-const UNCURSORED = new Set<NotebookEvent["event"]>([
-  "reset",
-  "marimo",
-  "unknown",
-]);
-
-/**
- * The notebook the event's object belongs to.
- *
- * Undefined for objects that do not name one.
- */
-function notebookIdOf(
-  event: ResourceEvent,
-): Protocol.NotebookIdOutput | undefined {
-  switch (event.event) {
-    case "document":
-      return event.data.document.notebook_id;
-    case "cell":
-      return event.data.cell.notebook_id;
-    case "analysis":
-      return event.data.analysis.notebook_id;
-    case "runtime":
-      return event.data.runtime.notebook_id;
-    case "attachment":
-      return event.data.attachment.notebook_id;
-    case "run":
-      return event.data.run.notebook_id;
-    default:
-      return undefined;
-  }
-}
-
-/** Compose resources into one stream. */
-export function createStream<States extends object>(
-  resources: Resources<States>,
-): Stream<States> {
-  const names = Object.keys(resources) as (keyof States & string)[];
-  const initialResources = Object.fromEntries(
-    names.map((name) => [name, resources[name].initial]),
-  ) as States;
-  const initial: StreamState<States> = {
-    phase: "snapshot",
-    notebookId: null,
-    cursor: null,
-    resources: initialResources,
-  };
-
-  function identify(
-    state: StreamState<States>,
-    notebookId: Protocol.NotebookIdOutput,
-  ): StreamState<States> {
-    if (state.notebookId === notebookId) {
-      return state;
-    }
-    if (state.notebookId !== null) {
-      throw new Error("Notebook stream changed identity");
-    }
-    return { ...state, notebookId };
-  }
-
-  function clear(state: StreamState<States>): StreamState<States> {
-    return state.resources === initialResources
-      ? state
-      : { ...state, resources: initialResources };
-  }
-
-  function fanOut(
-    state: StreamState<States>,
-    event: ResourceEvent,
-  ): StreamState<States> {
-    const context: HandlerContext = { phase: state.phase };
-    let next = state.resources;
-    for (const name of names) {
-      type State = States[typeof name];
-      // Handlers are keyed by the event name they accept.
-      const handler = resources[name].on[event.event] as
-        | ((
-            state: State,
-            event: Protocol.EventOutput,
-            context: HandlerContext,
-          ) => State)
-        | undefined;
-      if (handler === undefined) {
-        continue;
-      }
-      const before = next[name];
-      const after = handler(before, event, context);
-      if (after !== before) {
-        next = { ...next, [name]: after };
-      }
-    }
-    return next === state.resources ? state : { ...state, resources: next };
-  }
-
-  /** Record the position of a live event. */
-  function advance(
-    state: StreamState<States>,
-    id: string | undefined,
-  ): StreamState<States> {
-    return state.phase === "live" && id !== undefined && id !== state.cursor
-      ? { ...state, cursor: id }
-      : state;
-  }
-
-  return {
-    initial,
-    reduce(state, event) {
-      if (
-        state.phase === "live" &&
-        event.id === undefined &&
-        !UNCURSORED.has(event.event)
-      ) {
-        throw new Error("Live notebook event is missing its cursor");
-      }
-      switch (event.event) {
-        case "marimo":
-        case "unknown":
-          return advance(state, event.id);
-        case "reset":
-          return { ...initial, notebookId: state.notebookId };
-        case "ready":
-          // Handlers see the phase that ended, so a snapshot's ready differs
-          // from one that ends a replay.
-          return { ...fanOut(state, event), phase: "live", cursor: event.id };
-        case "notebook":
-          return advance(identify(state, event.data.notebook.id), event.id);
-        case "notebook.removed":
-          return advance(
-            state.notebookId !== null && event.data.id !== state.notebookId
-              ? state
-              : clear(state),
-            event.id,
-          );
-        default: {
-          const notebookId = notebookIdOf(event);
-          return advance(
-            fanOut(
-              notebookId === undefined ? state : identify(state, notebookId),
-              event,
-            ),
-            event.id,
-          );
-        }
-      }
-    },
-    resume(state) {
-      return state.phase === "snapshot"
-        ? { ...initial, notebookId: state.notebookId }
-        : state;
-    },
-  };
-}