pi-weave 0.1.12 → 0.1.13

package/src/web/client/live.model.ts

@@ -1,275 +0,0 @@
-/**
- * The liveness state machine, as pure data (weave-workspace §6).
- *
- * `src/web/server/sse.ts` pushes `{scope, stamp}` frames at the browser; this
- * module decides two things about them, and nothing else:
- *
- *  1. **What must be refetched** — a {@link RefetchPlan}.
- *  2. **What the status bar should say** — a `ConnectionState`.
- *
- * It is a `.model.ts` for the reason §10 gives: there is no DOM test
- * environment in this repository and we may not add one, so every decision
- * worth getting right lives in a pure function over plain objects and
- * {@link ./live} is left with nothing but socket plumbing. Everything here
- * runs under the root `tsconfig.json`, which has no `DOM` lib — hence no
- * `EventSource`, no `MessageEvent`, and `readyState` arriving as a plain
- * number.
- *
- * ## Frames are hints, not deltas
- *
- * §6 is explicit that macOS `fs.watch` coalesces and can drop events, so a
- * frame means "something in this scope moved, re-read it" and never "here is
- * what changed". That single sentence is why {@link planFor} returns *which
- * endpoints to re-request* rather than a patch, and why there is no code here
- * that tries to apply a frame to a graph in place. A client that treated
- * frames as deltas would diverge silently the first time the OS dropped one,
- * and the divergence would be invisible until someone noticed a stale node an
- * hour later.
- *
- * ## Reconnect refetches everything
- *
- * The server keeps **no replay buffer** and ignores `Last-Event-ID` (see the
- * `sse.ts` header). So a reopened stream carries no information about the gap,
- * and the only correct response to "I was away for an unknown interval" is to
- * re-request everything. That is what {@link reduceLive} produces for a
- * reopen, and it is cheap rather than wasteful: the graph request carries
- * `If-None-Match`, so an unchanged workspace costs one `304` with an empty
- * body. Buffering would add retention, eviction and a resume path to arrive
- * at the same fetch.
- */
-
-import type { ChangeEvent, ChangeScope } from "../shared/wire";
-import { isChangeEvent } from "../shared/wire";
-import type { ConnectionState } from "./state";
-
-/** The SSE endpoint (§5.3). */
-export const EVENTS_PATH = "/events";
-
-// --- `EventSource.readyState`, without the DOM lib ------------------------------
-
-/**
- * The three `readyState` values, restated as local constants.
- *
- * `EventSource.CONNECTING` and friends are DOM globals and this module is
- * compiled by a project with no `DOM` lib, so the numbers are written down
- * here. They are fixed by the HTML specification and cannot drift — unlike,
- * say, an HTTP status, there is no version of the standard in which `CLOSED`
- * stops being `2`.
- */
-export const SOCKET_CONNECTING = 0;
-export const SOCKET_OPEN = 1;
-export const SOCKET_CLOSED = 2;
-
-// --- refetch plans ---------------------------------------------------------------
-
-/**
- * Which endpoints a transition invalidates.
- *
- * Two booleans rather than a set of route names, because at P1 there are
- * exactly two things the shell holds: the graph payload and the selected
- * note's body. This will grow — P2 adds the `.okf` file view and the tag
- * index — and the honest thing is to let it grow then rather than to invent a
- * registry now for endpoints that do not exist.
- */
-export interface RefetchPlan {
-  /** Re-request `GET /api/graph`, conditionally on the held stamp. */
-  readonly graph: boolean;
-  /** Re-request `GET /api/note/:slug` for the current selection. */
-  readonly note: boolean;
-}
-
-/** Nothing to do. Returned for a deduped frame and for an idle transition. */
-export const NO_REFETCH: RefetchPlan = { graph: false, note: false };
-
-/** Whether a plan would issue no requests at all. */
-export function isNoop(plan: RefetchPlan): boolean {
-  return !plan.graph && !plan.note;
-}
-
-/**
- * Scope → what it can possibly have invalidated.
- *
- * The table is deliberately thin, and worth stating plainly rather than
- * dressing up: **every** scope invalidates the graph, because the graph
- * carries the vault's notes, the repository index *and* the git-state node
- * plus its staleness report. The one real distinction is the note body — a
- * `repo` or `git` change cannot alter the text of a note on disk, so the note
- * column is left alone, while a `vault` change can and must re-read it.
- *
- * Inventing finer granularity here would be fiction. When P2 gives the client
- * more than two things to hold, this table earns more rows.
- *
- * @param hasSelection whether a note is currently open in the note column;
- *   with nothing selected there is no note to refetch.
- */
-export function planFor(scope: ChangeScope, hasSelection: boolean): RefetchPlan {
-  return { graph: true, note: scope === "vault" && hasSelection };
-}
-
-/**
- * The "I have been away" plan: everything the client holds.
- *
- * Used for a reopened stream and for the header's manual `⟳`. Both mean the
- * same thing — the client cannot reason about what it missed — so they get
- * the same answer rather than two subtly different ones.
- */
-export function planForEverything(hasSelection: boolean): RefetchPlan {
-  return { graph: true, note: hasSelection };
-}
-
-// --- state --------------------------------------------------------------------------
-
-/**
- * Everything the liveness layer remembers.
- *
- * `stamp` is the dedupe key and doubles as the `If-None-Match` value the
- * shell sends. It is kept across a disconnect on purpose: a reconnect
- * refetches everything, but it refetches *conditionally*, so holding the last
- * known stamp turns "refetch everything" into a `304` whenever nothing
- * actually moved while we were away.
- */
-export interface LiveState {
-  readonly connection: ConnectionState;
-  /** Last stamp the client has applied, or `null` before the first graph. */
-  readonly stamp: string | null;
-  /**
-   * Whether the stream has ever been open.
-   *
-   * The discriminator between "first connect" and "reconnect", which is the
-   * only reason this flag exists. The first open needs no forced refetch —
-   * the shell fetches the graph on mount — while every later open does.
-   */
-  readonly opened: boolean;
-}
-
-/** Before the socket is created. Matches `state.ts`'s documented defaults. */
-export function initialLiveState(): LiveState {
-  return { connection: "live", stamp: null, opened: false };
-}
-
-/**
- * Record a stamp the client now holds.
- *
- * Called by the shell after any successful graph fetch, including the one on
- * mount. That seeding is what makes the server's hello frame free: `sse.ts`
- * sends the current stamp to every newly attached client, and a client that
- * already fetched that stamp at mount would otherwise treat it as news and
- * fetch a second time.
- *
- * The race is still possible — the hello frame can beat the mount fetch — and
- * it is deliberately not defended against. Losing it costs one conditional
- * GET that answers `304`, and the machinery to prevent that would be worth
- * more than the request it saves.
- */
-export function withStamp(state: LiveState, stamp: string): LiveState {
-  return state.stamp === stamp ? state : { ...state, stamp };
-}
-
-// --- events -------------------------------------------------------------------------
-
-/**
- * What can happen to the stream.
- *
- * `error` carries the socket's `readyState` because that is the *only* way to
- * tell the two failures apart: `EventSource` fires the same `error` event
- * when it is about to retry (`CONNECTING`) and when it has given up
- * (`CLOSED`). Reading the flag is not an optimisation — without it the status
- * bar cannot distinguish "back in a moment" from "this session is over", and
- * would have to pick one and be wrong half the time.
- */
-export type LiveEvent =
-  | { readonly type: "open" }
-  | { readonly type: "error"; readonly readyState: number }
-  | { readonly type: "frame"; readonly event: ChangeEvent }
-  /** The header's `⟳`. Not a socket event; refetches without touching state. */
-  | { readonly type: "refresh" }
-  /** The client closed the stream itself — navigation, or `stop()`. */
-  | { readonly type: "closed" };
-
-/** The result of one transition: the next state, and what to go and fetch. */
-export interface LiveTransition {
-  readonly state: LiveState;
-  readonly plan: RefetchPlan;
-}
-
-/**
- * Map a socket `readyState` at the moment of an error to a status.
- *
- * `CLOSED` is terminal: `EventSource` only reaches it after it has stopped
- * retrying, so `"offline"` is a statement of fact rather than a guess. Any
- * other value means a retry is scheduled, which is `"reconnecting"`. An
- * unrecognised number lands there too — the safe direction, because a status
- * bar that says "reconnecting" while the client is in fact dead is a smaller
- * lie than one that says "offline" while a retry is in flight, and the next
- * `open` or `error` corrects it either way.
- */
-export function connectionForError(readyState: number): ConnectionState {
-  return readyState === SOCKET_CLOSED ? "offline" : "reconnecting";
-}
-
-/**
- * The whole liveness state machine.
- *
- * @param hasSelection whether the note column currently holds a note. Passed
- *   in rather than stored, because it is owned by `selectedId` in
- *   `state.ts` and duplicating it here would create a second copy to keep in
- *   sync — the exact failure §1.3 avoids by having one signal.
- */
-export function reduceLive(state: LiveState, event: LiveEvent, hasSelection: boolean): LiveTransition {
-  switch (event.type) {
-    case "open": {
-      // A reopen means an unknown gap: see the module header. The first open
-      // is not a gap — nothing preceded it — so it only flips the status.
-      const plan = state.opened ? planForEverything(hasSelection) : NO_REFETCH;
-      return { state: { ...state, connection: "live", opened: true }, plan };
-    }
-
-    case "error":
-      return { state: { ...state, connection: connectionForError(event.readyState) }, plan: NO_REFETCH };
-
-    case "frame": {
-      // The dedupe that makes the hello frame free, and that absorbs the
-      // watcher's debounce emitting two frames for one save. The stamp is a
-      // content digest of the graph payload (§5.3), so an identical stamp
-      // provably means identical content — which is what entitles this line
-      // to skip a refetch. It was `generatedAt` until §15.6, and a timestamp
-      // max does *not* carry that guarantee: an edit that did not move the
-      // maximum was discarded right here, before the conditional GET that
-      // would have caught it ever ran.
-      if (event.event.stamp === state.stamp) return { state, plan: NO_REFETCH };
-      // The stamp is *not* recorded here. It becomes ours when the refetch it
-      // triggers succeeds — recording it now would mean a failed fetch left
-      // the client believing it holds data it never received, and the next
-      // frame carrying the same stamp would be deduped away.
-      return { state: { ...state, connection: "live" }, plan: planFor(event.event.scope, hasSelection) };
-    }
-
-    case "refresh":
-      return { state, plan: planForEverything(hasSelection) };
-
-    case "closed":
-      return { state: { ...state, connection: "offline" }, plan: NO_REFETCH };
-  }
-}
-
-// --- frame decoding ------------------------------------------------------------------
-
-/**
- * Decode one SSE `data:` line, or `null`.
- *
- * Total by design. This runs inside a socket callback on bytes that survived
- * a server restart, a proxy and whatever else sits on loopback, so a
- * malformed frame must cost a skipped refetch — never an unhandled rejection
- * that kills the listener and silently ends liveness for the session.
- * {@link isChangeEvent} does the structural half; this adds the `JSON.parse`
- * that can throw.
- */
-export function parseFrame(data: string): ChangeEvent | null {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(data);
-  } catch {
-    return null;
-  }
-  return isChangeEvent(parsed) ? parsed : null;
-}

package/src/web/client/live.ts

@@ -1,151 +0,0 @@
-/**
- * The SSE socket, wired to {@link ./live.model} (weave-workspace §6).
- *
- * Everything that decides anything lives in `live.model.ts`. This file owns
- * exactly one thing the model cannot: a real `EventSource`, its three
- * listeners, and the fact that it must be closed. Keeping that separation
- * sharp is what lets the whole liveness layer be unit-tested with no DOM —
- * §10's constraint, and the reason `.model.ts` files exist at all.
- *
- * ## The socket is injected
- *
- * {@link startLive} takes a factory rather than calling `new EventSource`.
- * The DOM one is the default at the call site in the shell, and a test passes
- * a fake with the same four members. This is the same port-shaped injection
- * `api.ts` uses for `fetch` and for the same reason: without it, the only way
- * to reach the reconnect path would be a browser.
- *
- * ## Why the connection state is written here and not in the model
- *
- * The model is pure and returns a next state; something has to publish it to
- * the `connection` signal that the status bar reads. That publication is this
- * file's other job, and it is one line — which is the correct amount of logic
- * for a file with no test harness behind it.
- */
-
-import type { ChangeScope } from "../shared/wire";
-import { CHANGE_EVENT_NAME } from "../shared/wire";
-import type { LiveEvent, LiveState, RefetchPlan } from "./live.model";
-import { EVENTS_PATH, initialLiveState, isNoop, parseFrame, reduceLive, withStamp } from "./live.model";
-import { connection } from "./state";
-
-/**
- * The slice of `EventSource` this module uses.
- *
- * Structural, so the platform's satisfies it without a cast and a fake is an
- * object literal. Two details are load-bearing:
- *
- * **`addEventListener` for all three events, not `onopen`/`onerror`.** The
- * handler properties are the more obvious spelling and they do not typecheck:
- * a property of function type is checked *contravariantly* under
- * `strictFunctionTypes`, so a port declaring `onopen: ((e: unknown) => void)`
- * rejects the platform's `(ev: Event) => any` — `unknown` is not assignable
- * to `Event`. Method declarations are compared bivariantly, so the single
- * `addEventListener` form accepts the real `EventSource` without a cast and
- * without this module ever naming a DOM type.
- *
- * **`{data: string}` rather than `MessageEvent`.** This file is compiled by
- * `tsconfig.web.json` for the bundle *and* pulled into the root project when
- * a test imports it, and the root project has no `DOM` lib. The narrow shape
- * is the only one both projects can resolve. `open` and `error` carry no
- * payload this module reads, so they receive it and ignore it.
- */
-export interface EventSourceLike {
-  /** `0` connecting, `1` open, `2` closed. See `live.model.ts`'s constants. */
-  readonly readyState: number;
-  addEventListener(type: string, listener: (event: { data: string }) => void): void;
-  close(): void;
-}
-
-/** Creates a stream for a URL. The DOM's `EventSource` constructor fits. */
-export type EventSourceFactory = (url: string) => EventSourceLike;
-
-/** What {@link startLive} needs from its host. */
-export interface LiveOptions {
-  /** Injected socket constructor. */
-  open: EventSourceFactory;
-  /**
-   * Run a refetch plan. Async and awaited nowhere — a fetch that outlives the
-   * socket is the caller's problem to make idempotent, and the shell's is.
-   */
-  refetch: (plan: RefetchPlan) => void;
-  /** Whether a note is open, read fresh per event. See `reduceLive`. */
-  hasSelection: () => boolean;
-  /** The stream URL. Defaults to {@link EVENTS_PATH}. */
-  path?: string;
-}
-
-/** A running stream. */
-export interface LiveHandle {
-  /** Close the socket and mark the connection offline. Idempotent. */
-  stop(): void;
-  /** Force a full refetch — the header's `⟳`. */
-  refresh(): void;
-  /** Record a stamp the client now holds, so the next frame can dedupe it. */
-  seen(stamp: string): void;
-  /** Current state. For tests and the status bar's tooltip. */
-  state(): LiveState;
-}
-
-/**
- * Attach to the event stream.
- *
- * Note what this does *not* do: reconnect. `EventSource` reconnects natively
- * with its own backoff, which is most of why §6 chose it over a WebSocket, so
- * a retry loop here would be a second one racing the browser's.
- */
-export function startLive(opts: LiveOptions): LiveHandle {
-  let state = initialLiveState();
-  let stopped = false;
-
-  const source = opts.open(opts.path ?? EVENTS_PATH);
-
-  /** The single path from a socket event to a state change and a refetch. */
-  const dispatch = (event: LiveEvent): void => {
-    const next = reduceLive(state, event, opts.hasSelection());
-    state = next.state;
-    connection.value = state.connection;
-    if (!isNoop(next.plan)) opts.refetch(next.plan);
-  };
-
-  source.addEventListener("open", () => dispatch({ type: "open" }));
-  source.addEventListener("error", () => dispatch({ type: "error", readyState: source.readyState }));
-  source.addEventListener(CHANGE_EVENT_NAME, (event) => {
-    const frame = parseFrame(event.data);
-    // A frame we cannot read is dropped rather than escalated: the next one
-    // carries the same "something moved" meaning, and the heartbeat proves
-    // the socket is still alive meanwhile.
-    if (frame !== null) dispatch({ type: "frame", event: frame });
-  });
-
-  return {
-    stop() {
-      if (stopped) return;
-      stopped = true;
-      source.close();
-      dispatch({ type: "closed" });
-    },
-    refresh() {
-      dispatch({ type: "refresh" });
-    },
-    seen(stamp: string) {
-      state = withStamp(state, stamp);
-    },
-    state() {
-      return state;
-    },
-  };
-}
-
-/**
- * `new EventSource(url)`, as an {@link EventSourceFactory}.
- *
- * The one place in the liveness layer that names a DOM global, isolated here
- * so that everything else in it compiles and runs under Node.
- */
-export function domEventSource(url: string): EventSourceLike {
-  return new EventSource(url);
-}
-
-/** Re-exported so the shell imports its liveness vocabulary from one module. */
-export type { ChangeScope, LiveState, RefetchPlan };

package/src/web/client/note/Editor.tsx

@@ -1,109 +0,0 @@
-/**
- * The `<textarea>` editor and its toolbar (weave-workspace §0 V10, §11 P5.4).
- *
- * Props in, JSX out. Dirty tracking, the save lifecycle, conflict resolution
- * and every string are `editor.model.ts`; the requests are `editor.ts`. What
- * is left here is three elements and three handlers.
- *
- * A `<textarea>`, not CodeMirror 6, and §0 V10 settles it with a number:
- * CM6 is 118 KB gzip — more than the entire rest of the client — against a
- * 150 KB budget already 62 % spent. The textarea is what proves the *save
- * path* is correct, which is the part P5 is actually gated on. Syntax
- * highlighting can arrive later against a round trip that is already known
- * to be lossless; the reverse order would be building an editor over a bug.
- */
-
-import type { EditorEvent, EditorPrompt, EditorToolbar } from "./editor.model";
-import { editorBarVisible } from "./editor.model";
-
-export interface EditorProps {
-  toolbar: EditorToolbar;
-  /** The `<textarea>`'s content — `state.draft`. */
-  draft: string;
-  /** The one prompt to show, or `null`. Ordered by `editorPrompt`. */
-  prompt: EditorPrompt | null;
-  /** Dispatch into the controller. The only way anything here changes state. */
-  send: (event: EditorEvent) => void;
-}
-
-/** The conflict / discard / external-change prompt. */
-function Prompt({ prompt, send }: { prompt: EditorPrompt; send: (event: EditorEvent) => void }) {
-  return (
-    <div class={`weave-note-prompt weave-note-prompt-${prompt.kind}`} role="alert">
-      <p class="weave-note-prompt-text">{prompt.message}</p>
-      <p class="weave-note-prompt-actions">
-        {prompt.actions.map((action) => (
-          <button key={action.label} type="button" class="weave-note-action" onClick={() => send(action.event)}>
-            {action.label}
-          </button>
-        ))}
-      </p>
-    </div>
-  );
-}
-
-/** The toolbar while editing: done, save, and the status word.
- *
- * `Open in $EDITOR` no longer lives here (P6.3): as the bar's only read-mode
- * inhabitant it read as the note's headline control, a full-width bordered
- * shout before the prose began. It is an icon in the head's meta row instead
- * — same event, same hint, one third the visual weight — and
- * `editorBarVisible` is what keeps the read view down to prose rather than a
- * bar announcing nothing. */
-export function EditorBar(props: EditorProps) {
-  const { toolbar, send } = props;
-  if (!editorBarVisible(toolbar, props.prompt)) return null;
-  return (
-    <div class="weave-note-bar">
-      {toolbar.editing ? (
-        <button
-          type="button"
-          class="weave-note-toggle"
-          aria-pressed={toolbar.editing}
-          onClick={() => send({ type: "toggle" })}
-        >
-          {toolbar.toggleLabel}
-        </button>
-      ) : null}
-      {toolbar.editing ? (
-        <button type="button" class="weave-note-save" disabled={!toolbar.canSave} onClick={() => send({ type: "save" })}>
-          {toolbar.saveLabel}
-        </button>
-      ) : null}
-      {toolbar.dirty ? (
-        <span class="weave-note-dirty" title="unsaved changes" aria-hidden="true">
-          •
-        </span>
-      ) : null}
-      {toolbar.message === null ? null : <span class={`weave-note-status weave-note-status-${toolbar.tone}`}>{toolbar.message}</span>}
-      {props.prompt === null ? null : <Prompt prompt={props.prompt} send={send} />}
-    </div>
-  );
-}
-
-/**
- * The editing surface.
- *
- * `⌘S` is handled here as well as globally, and deliberately: the global
- * `keydown` listener sees every keystroke in the workspace, so claiming a
- * modifier combination there is a workspace-wide claim. Handling it on the
- * textarea too means the save fires from the element that owns the text even
- * if the global map is later narrowed — and `keys.model.ts` returns `null`
- * for anything it does not claim, so the two never fight over one event.
- */
-export function Editor(props: EditorProps) {
-  return (
-    <textarea
-      class="weave-note-editor"
-      aria-label="Note body"
-      spellcheck
-      value={props.draft}
-      onInput={(event) => props.send({ type: "draft", text: (event.target as HTMLTextAreaElement).value })}
-      onKeyDown={(event) => {
-        if (event.key.toLowerCase() !== "s" || !(event.metaKey || event.ctrlKey)) return;
-        event.preventDefault();
-        props.send({ type: "save" });
-      }}
-    />
-  );
-}

package/src/web/client/note/editor.controller.ts

@@ -1,151 +0,0 @@
-/**
- * The editor's effects: three requests and an unload listener
- * (weave-workspace §10, §11 P5).
- *
- * `editor.model.ts` decides *whether* to save, *what* to send and *what a
- * response means*; it cannot issue a request or subscribe to `beforeunload`
- * without ceasing to be pure. This is the other half — a controller whose
- * every capability is injected, in the shape `search.ts` established.
- *
- * ## Why `editor.controller.ts` and not `editor.ts`
- *
- * The pairing everywhere else in the client is `x.model.ts` + `x.ts`
- * (`search.model.ts`/`search.ts`, `live.model.ts`/`live.ts`), and that is the
- * name this file wanted. It cannot have it: the component beside it is
- * `Editor.tsx`, and on a case-insensitive filesystem — which is the macOS
- * default — `editor.ts` and `Editor.tsx` are the same path prefix. TypeScript
- * says so directly (`TS1149: File name … differs from already included file
- * name … only in casing`) and the build is a hard error rather than a
- * warning. Renaming the *component* instead would break the `.tsx` = view
- * convention the whole client is read by, so the controller takes the longer
- * name. The capabilities it needs are:
- *
- *  - a **`FetchLike`**, the same port `api.ts` takes, so no DOM is involved;
- *  - a **`select`**, so completing a parked navigation goes through §1.3's
- *    context bus rather than this module knowing what a selection is.
- *
- * The result is that the editor's whole asynchronous behaviour — the save
- * round trip, the `409`, the stale-response guard, the unload block — is
- * covered by ordinary unit tests, and `Editor.tsx` is a `<textarea>` and
- * three handlers.
- *
- * ## Why the controller owns the dispatch loop
- *
- * Every event goes through {@link EditorHandle.send}, which reduces,
- * publishes, and then performs whichever effect the transition asked for.
- * There is no other path that mutates state. That is what makes "a save
- * cannot start while a conflict is unresolved" and "a stale response cannot
- * overwrite the draft" enforceable: the checks live in the reducer, and every
- * response arrives back through here.
- */
-
-import type { FetchLike } from "../api";
-import { openNote, saveNote } from "../api";
-import type { EditorEffect, EditorEvent, EditorState } from "./editor.model";
-import { initialEditorState, reduceEditor, shouldBlockUnload } from "./editor.model";
-
-/**
- * The slice of `beforeunload` this module touches.
- *
- * Structural, and `returnValue` is included because that is the only form
- * every browser still honours: `preventDefault()` alone is the spec's answer
- * and Chrome ignored it for years. Setting both is the portable spelling.
- */
-export interface BeforeUnloadEventLike {
-  preventDefault(): void;
-  returnValue?: unknown;
-}
-
-/** The slice of `window` the unload guard subscribes to. */
-export interface UnloadHost {
-  addEventListener(type: "beforeunload", listener: (event: BeforeUnloadEventLike) => void): void;
-  removeEventListener(type: "beforeunload", listener: (event: BeforeUnloadEventLike) => void): void;
-}
-
-/** What {@link createEditor} needs. Every capability injected. */
-export interface EditorOptions {
-  fetch: FetchLike;
-  /** The §1.3 context bus. Called to complete a navigation the editor held. */
-  select: (id: string | null) => void;
-  /** Called after every state change, so the component can re-render. */
-  onChange: (state: EditorState) => void;
-}
-
-/** A running editor. */
-export interface EditorHandle {
-  /** Current state. Read at render. */
-  state(): EditorState;
-  /** Dispatch an event. The only way state moves. */
-  send(event: EditorEvent): void;
-}
-
-export function createEditor(opts: EditorOptions): EditorHandle {
-  let state = initialEditorState();
-
-  const send = (event: EditorEvent): void => {
-    const next = reduceEditor(state, event);
-    state = next.state;
-    opts.onChange(state);
-    if (next.effect !== null) perform(next.effect);
-  };
-
-  const perform = (effect: EditorEffect): void => {
-    if (effect.type === "select") {
-      opts.select(effect.id);
-      return;
-    }
-    // Fire and forget: `api.ts` returns failures as values, so there is
-    // nothing to reject and nothing to catch. `void` documents the floating
-    // promise rather than hiding it — the same shape `workspace.ts` and
-    // `search.ts` use.
-    if (effect.type === "open") {
-      void (async () => {
-        const result = await openNote(opts.fetch, effect.slug);
-        send({ type: "opened", ok: result.ok && result.data.opened });
-      })();
-      return;
-    }
-    void (async () => {
-      const result = await saveNote(opts.fetch, effect.slug, effect.input);
-      if (result.ok) {
-        send({ type: "saved", payload: result.data });
-        return;
-      }
-      // The `409` is not an error in the sense the other five kinds are —
-      // it is the server handing back the information the user needs in
-      // order to choose. `api.ts` gives it its own arm for exactly this
-      // branch.
-      send(result.kind === "conflict" ? { type: "conflicted", conflict: result.conflict } : { type: "failed", message: result.message });
-    })();
-  };
-
-  return { state: () => state, send };
-}
-
-/**
- * Block `beforeunload` while the draft is dirty. Returns an unsubscribe.
- *
- * The predicate is a thunk, not a value: a listener registered at mount
- * outlives every render, so a captured state would answer with the editor as
- * it was when the tab opened — which is always clean, making the guard a
- * no-op that looks installed.
- *
- * No custom message: every browser has ignored the string since 2017 and
- * shows its own wording. Returning one would be writing code whose only
- * effect is to suggest, to the next reader, that it does something.
- */
-export function watchUnload(host: UnloadHost, dirty: () => boolean): () => void {
-  const listener = (event: BeforeUnloadEventLike): void => {
-    if (!dirty()) return;
-    event.preventDefault();
-    // The legacy half. Chrome required a truthy `returnValue` long after the
-    // spec settled on `preventDefault`, and setting both is the only
-    // spelling that works everywhere.
-    event.returnValue = "";
-  };
-  host.addEventListener("beforeunload", listener);
-  return () => host.removeEventListener("beforeunload", listener);
-}
-
-/** {@link shouldBlockUnload}, re-exported so the shell imports one module. */
-export { shouldBlockUnload };