pi-weave 0.1.12 → 0.1.13

package/src/pi/viewer/tui/workspaceRoot.ts

@@ -1,22 +1,20 @@
 /**
  * workspaceRoot.ts — the v2 workspace ROOT component (weave-view-tui-v2 §4, §7).
  *
- * Sits above the pure `workspace.ts` split-tree model and the `surface/*`
+ * Sits above the pure fixed `workspace.ts` model and the `surface/*`
  * components. It composes panes from a `Workspace` value into a real pi-tui
- * tree (VStack/HStack/Pane), owns the single input listener, routes keys
- * (workspace §7.1 / pane §7.2) and cross-pane SurfaceEvents, renders the
+ * tree (HStack/Pane), owns the single input listener, routes keys and
+ * cross-pane SurfaceEvents, renders the
  * branded header + footer + narrow-mode tab bar (§9.2, decision 5), and
  * applies responsive collapse.
  *
- * It is drivable with a fake tui/theme/loaders exactly like v1's WeaveExplorer.
- * `WeaveExplorer` (v1 single-pane path) is kept intact for backward
- * compatibility; the workspace root is the v2 multi-pane path wired in run.ts.
+ * It is drivable with a fake tui/theme/loaders and is the path wired in run.ts.
  */
 
-import { HStack, matchesKey, truncateToWidth, visibleWidth, VStack, type Component } from "@earendil-works/pi-tui";
+import { HStack, matchesKey, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
 import { BodyStore } from "./bodyStore";
 import { renderMark } from "./branding";
-import type { WeaveLoaders, WeaveTheme, WeaveTui } from "./explorer";
+import type { WeaveLoaders, WeaveTheme, WeaveTui } from "./surface/base";
 import { countProvenance } from "./model";
 import type { GraphModel, GraphNode } from "../../../core/graph/model";
 import { Pane } from "./surface/base";
@@ -25,19 +23,7 @@ import { ExploreSurface } from "./surface/explore";
 import { bindDetail, DetailSurface } from "./surface/detail";
 import { FocusSurface } from "./surface/focus";
 import { HealthSurface } from "./surface/health";
-import {
-  close,
-  collapseForWidth,
-  defaultWorkspace,
-  focusNext,
-  resize,
-  setPaneSurface,
-  split,
-  workspacePanes,
-  type PaneNode,
-  type Workspace,
-  type WorkspaceNode,
-} from "./workspace";
+import { collapseForWidth, defaultWorkspace, focusNext, workspacePanes, type PaneNode, type Workspace } from "./workspace";
 
 export interface WeaveWorkspaceOptions {
   model: GraphModel;
@@ -47,24 +33,10 @@ export interface WeaveWorkspaceOptions {
   done: (result: null) => void;
   rows?: number;
   now?: () => number;
-  /** Pre-rendered brand mark line (from branding.renderMark). */
-  logo?: string;
-  /**
-   * Raster kitty logo (branding.bundledLogoImage) rendered on its own row(s)
-   * above the header text strip when Kitty graphics are available. `null`/
-   * absent keeps the one-line glyph header (decision 1 favicon, not a splash).
-   */
-  logoImage?: Component | null;
-  /** Optional initial workspace (defaults to the Explore default). */
-  workspace?: Workspace;
 }
 
-/** Decode a workspace-level key (returns null when it's a pane key). */
+/** Decode the few root-level keys; all other input belongs to the active surface. */
 export function decodeWorkspaceKey(data: string): string | null {
-  if (data === "\\") return "splitV";
-  if (data === "|") return "splitH";
-  if (data === "x") return "close";
-  if (data === "w") return "workspace";
   if (data === "?") return "help";
   if (data === "q") return "quit";
   if (data === "r") return "refresh";
@@ -80,12 +52,11 @@ export class WeaveWorkspace implements Component {
   private readonly rows: number;
   private readonly nowFn: () => number;
   private readonly logo: string;
-  private readonly logoImage: Component | null;
   private readonly bodies: BodyStore;
   private ctx: SurfaceContext;
   /** paneId → surface instance. */
   private panes = new Map<string, Surface>();
-  /** The workspace split tree + focus. */
+  /** The fixed pane layout + focus. */
   workspace: Workspace;
   private helpOpen = false;
   refreshing = false;
@@ -101,8 +72,7 @@ export class WeaveWorkspace implements Component {
     this.done = opts.done;
     this.rows = opts.rows ?? 24;
     this.nowFn = opts.now ?? Date.now;
-    this.logo = opts.logo ?? renderMark("glyph", opts.theme, 20);
-    this.logoImage = opts.logoImage ?? null;
+    this.logo = renderMark(opts.theme, 20);
     this.bodies = new BodyStore({
       loaders: opts.loaders,
       onChange: () => this.invalidateAndRender(),
@@ -114,7 +84,7 @@ export class WeaveWorkspace implements Component {
       bodies: this.bodies,
       now: this.nowFn,
     };
-    this.workspace = opts.workspace ?? defaultWorkspace(opts.model);
+    this.workspace = defaultWorkspace(opts.model);
     this.syncPanes();
   }
 
@@ -192,17 +162,6 @@ export class WeaveWorkspace implements Component {
       this.applyWorkspaceKey(wsKey);
       return;
     }
-    if (data === "e" || data === "d" || data === "h") {
-      this.swapSurface(data);
-      return;
-    }
-    // Ctrl+letters resize — only the four resize bytes are intercepted so
-    // enter (\r/0x0d), esc (0x1b) and other control keys reach the pane.
-    const ctrl = charCode(data);
-    if (ctrl !== undefined && (ctrl === 0x08 || ctrl === 0x0a || ctrl === 0x0b || ctrl === 0x0c)) {
-      this.applyResize(ctrl);
-      return;
-    }
     const active = this.activePane();
     if (active?.handleInput) {
       active.handleInput(data);
@@ -225,21 +184,6 @@ export class WeaveWorkspace implements Component {
 
   private applyWorkspaceKey(key: string): void {
     switch (key) {
-      case "splitV":
-        this.workspace = split(this.workspace, this.workspace.activePaneId, "vertical");
-        this.syncPanes();
-        this.invalidateAndRender();
-        return;
-      case "splitH":
-        this.workspace = split(this.workspace, this.workspace.activePaneId, "horizontal");
-        this.syncPanes();
-        this.invalidateAndRender();
-        return;
-      case "close":
-        this.workspace = close(this.workspace, this.workspace.activePaneId);
-        this.syncPanes();
-        this.invalidateAndRender();
-        return;
       case "quit":
         this.quit();
         return;
@@ -255,11 +199,6 @@ export class WeaveWorkspace implements Component {
             this.invalidateAndRender();
           });
         return;
-      case "workspace":
-        // TODO(M5): named-workspace switcher overlay; for now toggles help.
-        this.helpOpen = !this.helpOpen;
-        this.invalidateAndRender();
-        return;
       case "help":
         this.helpOpen = !this.helpOpen;
         this.invalidateAndRender();
@@ -267,28 +206,6 @@ export class WeaveWorkspace implements Component {
     }
   }
 
-  /** Ctrl+h/l adjust row weights; Ctrl+j/k adjust column weights. */
-  private applyResize(byte: number): void {
-    const active = this.workspace.activePaneId;
-    const d = 2;
-    if (byte === 0x08) this.workspace = resize(this.workspace, active, "row", -d); // Ctrl-h
-    else if (byte === 0x0c) this.workspace = resize(this.workspace, active, "row", d); // Ctrl-l
-    else if (byte === 0x0a) this.workspace = resize(this.workspace, active, "column", d); // Ctrl-j
-    else if (byte === 0x0b) this.workspace = resize(this.workspace, active, "column", -d); // Ctrl-k
-    this.syncPanes();
-    this.invalidateAndRender();
-  }
-
-  /** e/d/h — swap the active pane's surface in place (f stays the pane focus key). */
-  private swapSurface(key: string): void {
-    const kind = key === "e" ? "explore" : key === "d" ? "detail" : "health";
-    const activeId = this.workspace.activePaneId;
-    this.workspace = setPaneSurface(this.workspace, activeId, kind);
-    const s = this.createSurface({ type: "pane", id: activeId, surface: kind, nodeId: null });
-    this.panes.set(activeId, s);
-    this.invalidateAndRender();
-  }
-
   private cycleFocus(dir: 1 | -1): void {
     this.workspace = focusNext(this.workspace, dir);
     this.refreshFocusFlags();
@@ -331,27 +248,15 @@ export class WeaveWorkspace implements Component {
     if (node.detail.slug) void this.loaders.openNote(node.detail.slug);
   }
 
-  /** Obsidian "open in main": nearest Detail pane to the right, else split. */
+  /** Open a selected node in the fixed Detail pane. */
   private openDetail(id: string): void {
     // (The active Detail surface already rebinds itself on enter, so no
     // active-pane special case is needed here.)
     const panes = workspacePanes(this.workspace);
-    const activeIdx = panes.findIndex((p) => p.id === this.workspace.activePaneId);
-    const toRight = panes.slice(activeIdx + 1).find((p) => p.surface === "detail");
-    if (toRight) {
-      this.bindDetail(toRight.id, id);
-      this.setActive(toRight.id);
-      return;
-    }
-    // none to the right — split the active pane horizontally into a Detail
-    this.workspace = split(this.workspace, this.workspace.activePaneId, "horizontal", "detail");
-    this.syncPanes();
-    const detail = workspacePanes(this.workspace).find((p) => p.surface === "detail");
-    if (detail) {
-      this.bindDetail(detail.id, id);
-      this.setActive(detail.id);
-    }
-    this.invalidateAndRender();
+    const detail = panes.find((p) => p.surface === "detail");
+    if (!detail) return;
+    this.bindDetail(detail.id, id);
+    this.setActive(detail.id);
   }
 
   private bindDetail(paneId: string, id: string): void {
@@ -375,16 +280,7 @@ export class WeaveWorkspace implements Component {
       (this.panes.get(focus.id) as FocusSurface).setFocus(id);
       this.setActive(focus.id);
       this.invalidateAndRender();
-      return;
-    }
-    this.workspace = split(this.workspace, this.workspace.activePaneId, "horizontal", "focus");
-    this.syncPanes();
-    const fp = workspacePanes(this.workspace).find((p) => p.surface === "focus");
-    if (fp) {
-      (this.panes.get(fp.id) as FocusSurface).setFocus(id);
-      this.setActive(fp.id);
     }
-    this.invalidateAndRender();
   }
 
   private requestBody(id: string): void {
@@ -414,25 +310,11 @@ export class WeaveWorkspace implements Component {
     const repo = this.model.nodes.find((n) => n.kind === "repository");
     const repoState = repoStaleness(this.model, repo);
     const repoPart = repo ? ` · repo ${repo.label}:${repoState}` : "";
-    // Kitty: the raster logo leads on its own row(s) and replaces the glyph in
-    // the text strip (decision 1 favicon). Otherwise the one-line glyph header
-    // stays intact.
-    let imageLines: string[] | null = null;
-    if (this.logoImage) {
-      try {
-        const lines = this.logoImage.render(width);
-        if (lines && lines.length) imageLines = lines;
-      } catch {
-        imageLines = null;
-      }
-    }
-    const mark = imageLines ? "" : this.logo;
+    const mark = this.logo;
     const head = `${mark}${mark ? " " : ""}${t.bold("weave view")}`;
     const fill = "─".repeat(Math.max(1, width - visibleWidth(head) - 2));
     const line1 = `${head} ${fill} ${this.workspace.name} · ${workspacePanes(this.workspace).length} panes${repoPart}`;
-    const out: string[] = [];
-    if (imageLines) out.push(...imageLines);
-    out.push(truncateToWidth(line1, width));
+    const out: string[] = [truncateToWidth(line1, width)];
     const banner = this.bannerText();
     if (banner) out.push(t.fg("warning", truncateToWidth(banner, width)));
     const countsLine = `notes ${counts.total} (● ${counts.human} / ◐ ${counts.agent} / ○ ${counts.generated})`;
@@ -447,36 +329,19 @@ export class WeaveWorkspace implements Component {
   private renderBody(width: number): string[] {
     const effective = collapseForWidth(this.workspace, width);
     const bodyRows = Math.max(1, this.rows - 4);
-    const tree = this.buildSplit(effective.root, bodyRows);
-    return tree.render(width);
+    const stack = new HStack();
+    for (const pane of effective.panes) stack.addChild(this.buildPane(pane, bodyRows), { grow: 1 });
+    return stack.render(width);
   }
 
-  private buildSplit(node: WorkspaceNode, rows: number): Component {
-    if (node.type === "pane") {
-      const s = this.panes.get(node.id);
-      if (!s) return { render: () => [], invalidate: () => {} };
-      (s as { paneRows?: number }).paneRows = Math.max(1, rows - 3);
-      const p = new Pane(s, this.theme);
-      p.rows = rows;
-      p.setFocused(node.id === this.workspace.activePaneId);
-      return p;
-    }
-    const StackCtor = node.direction === "row" ? HStack : VStack;
-    const stack = new StackCtor();
-    // VStack stacks panes vertically, so each child's height must be its share
-    // of the available rows (by grow weight) — otherwise every child renders at
-    // full height, the stack overflows, and the render clamp leaves only the
-    // first pane visible (the "split hides the new pane" bug). HStack shares
-    // width, so its children keep the full height.
-    const vertical = node.direction !== "row";
-    const sizes = node.sizes.length ? node.sizes : node.children.map(() => 1);
-    const total = sizes.reduce((a, b) => a + b, 0) || node.children.length;
-    node.children.forEach((c, i) => {
-      const grow = sizes[i] ?? 1;
-      const childRows = vertical ? Math.max(1, Math.round((rows * grow) / total)) : rows;
-      stack.addChild(this.buildSplit(c, childRows), { grow });
-    });
-    return stack;
+  private buildPane(node: PaneNode, rows: number): Component {
+    const s = this.panes.get(node.id);
+    if (!s) return { render: () => [], invalidate: () => {} };
+    (s as { paneRows?: number }).paneRows = Math.max(1, rows - 3);
+    const p = new Pane(s, this.theme);
+    p.rows = rows;
+    p.setFocused(node.id === this.workspace.activePaneId);
+    return p;
   }
 
   private renderTabBar(width: number): string[] {
@@ -493,22 +358,16 @@ export class WeaveWorkspace implements Component {
     const t = this.theme;
     if (this.helpOpen) {
       const help = [
-        "Tab focus · \\ | split · Ctrl-hjkl resize · x close · e/d/f/h swap",
+        "Tab focus · ↑↓/jk move · ←→/hl expand · enter open · f focus · r refresh · ? help · q quit",
         "↑↓/jk move · ←→/hl expand · enter open · / filter · p prov · f focus · r refresh · ? help · q quit",
       ];
       return help.map((l) => t.fg("dim", truncateToWidth(l, width)));
     }
-    const hint = "Tab focus · \\ split · Ctrl-hjkl resize · e/d/f/h pane · r refresh · ? help · q quit";
+    const hint = "Tab focus · ↑↓/jk move · ←→/hl expand · enter open · f focus · r refresh · ? help · q quit";
     return [t.fg("dim", truncateToWidth(hint, width))];
   }
 }
 
-function charCode(data: string): number | undefined {
-  if (data.length !== 1) return undefined;
-  const c = data.charCodeAt(0);
-  return c >= 0 && c < 0x20 ? c : undefined;
-}
-
 /** True when the active surface is in a sub-mode that Esc should clear instead
  *  of quitting — Explore's search (`state.searching`) or Detail's goto-line
  *  (`state.gotoBuf`). Surfaces own their own state; read defensively so a

package/src/pi/viewer/web/run.ts

@@ -3,19 +3,15 @@
  * (weave-workspace §5.4, §6, §13).
  *
  * This is the adapter half of the browser workspace: everything portable
- * already lives in `src/core` (the cache) and `src/web/server` (the server,
- * the SSE hub, the watcher). What is left here is the wiring those three
+ * already lives in `src/core` (the cache) and `src/web/server` (the server).
+ * What is left here is the wiring those two
  * cannot do for themselves, because it is session-shaped:
  *
  *  1. **Composition.** Build one {@link WorkspaceCache} over `ctx.cwd` +
- *     the resolved vault root, one {@link SseHub}, one {@link Watcher}, and
- *     hand the last two to `startWorkspaceServer` so it owns their teardown.
- *  2. **The liveness loop.** `watcher.onPath → cache.invalidate` (evict
- *     precisely) and `watcher.onChange → cache.graph() → sse.broadcast`
- *     (one frame per scope). §6's diagram, in code.
- *  3. **Singleton per session.** A second `/weave-view` must reuse the
+ *     the resolved vault root and hand it to `startWorkspaceServer`.
+ *  2. **Singleton per session.** A second `/weave-view` must reuse the
  *     running server — a second server would mean a second port, a second
- *     watcher on the same directories, and a browser tab pointed at a
+ *     second browser tab pointed at a
  *     workspace nobody is going to close (§5.4).
  *  4. **Browser handoff**, with an honest fallback when there is no browser
  *     to hand off to.
@@ -40,15 +36,11 @@
 import { platform as osPlatform } from "node:os";
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { resolveVaultRoot, WorkspaceCache } from "../../../core";
-import { graphStamp, type Watcher as ServerWatcher } from "../../../web/server/routes";
 import {
   startWorkspaceServer,
   type StartWorkspaceServerOptions,
   type WorkspaceServer,
 } from "../../../web/server/server";
-import { SseHub } from "../../../web/server/sse";
-import { Watcher } from "../../../web/server/watcher";
-import type { ChangeScope } from "../../../web/shared/wire";
 
 /** The slice of `ExtensionAPI.exec` this module uses. */
 export type ExecFn = (command: string, args: string[]) => Promise<{ code: number; stderr: string }>;
@@ -73,73 +65,10 @@ export function browserOpenCommand(
   return { command: "xdg-open", args: [url] };
 }
 
-/**
- * The §6 liveness loop, as three callbacks over a cache and a hub.
- *
- * Extracted from the boot closure so it can be driven directly in a test
- * instead of through a real filesystem event: "a change arrives, the cache
- * is evicted, the graph is rebuilt, one frame per scope goes out" is the
- * behaviour worth asserting, and waiting on `fs.watch` to assert it would
- * be slow, platform-dependent and flaky for no gain.
- */
-export interface LivenessBridge {
-  /** One call per accepted path, immediately — precise eviction. */
-  onPath(absPath: string): void;
-  /** One call per debounce window — rebuild once, broadcast per scope. */
-  onChange(scopes: readonly ChangeScope[]): void;
-  /** The stamp a newly attached SSE client is told about. */
-  currentStamp(): string | null;
-  /** Test seam: resolves when the in-flight rebuild settles. */
-  settled(): Promise<void>;
-}
-
-export function createLivenessBridge(cache: WorkspaceCache, sse: SseHub): LivenessBridge {
-  // The last stamp we broadcast, or `null` before the first change. Held
-  // rather than derived because `currentStamp` is synchronous (sse.ts) and
-  // `cache.snapshot()` is not.
-  let lastStamp: string | null = null;
-  let inFlight: Promise<void> = Promise.resolve();
-
-  return {
-    onPath: (absPath) => cache.invalidate(absPath),
-    onChange: (scopes) => {
-      const done = (async () => {
-        // A rebuild can fail — the vault was deleted mid-session — and a
-        // failed broadcast must cost one missed frame, not an unhandled
-        // rejection inside a filesystem callback.
-        const snapshot = await cache.snapshot().catch(() => null);
-        if (snapshot === null) return;
-        // The *same* key `/api/graph` puts in its ETag (§5.3, §6): a content
-        // digest, not `generatedAt`.
-        //
-        // This is the half of §15.6 that was easy to miss. The client dedupes
-        // frames on `stamp` (`live.model.ts`) and already holds the stamp of
-        // the graph it last fetched, so while this broadcast a timestamp max,
-        // an edit that did not advance that maximum produced a frame the
-        // client discarded *before* issuing the conditional GET. The stale
-        // `304` was the second line of defence; this was the first, and it
-        // failed for the same three cases. Sharing one key fixes both.
-        //
-        // `snapshot()`, not `graph()`, because the payload — and therefore
-        // the digest — depends on the notes as well as the model (§4.3).
-        const stamp = graphStamp(snapshot);
-        lastStamp = stamp;
-        for (const scope of scopes) sse.broadcast({ scope, stamp });
-      })();
-      inFlight = inFlight.then(() => done);
-    },
-    currentStamp: () => lastStamp,
-    settled: () => inFlight,
-  };
-}
-
 /** Everything one running workspace owns. Closed as a unit. */
 export interface WebWorkspaceSession {
   server: WorkspaceServer;
   cache: WorkspaceCache;
-  sse: SseHub;
-  watcher: Watcher;
-  liveness: LivenessBridge;
 }
 
 export interface WebWorkspaceDeps {
@@ -223,7 +152,7 @@ export class WebWorkspaceController {
     return { session, started, opened, fallbackToTui: wantsBrowser && !opened };
   }
 
-  /** Stop the workspace: server, watcher and every SSE stream. Idempotent. */
+  /** Stop the workspace server. Idempotent. */
   async close(): Promise<void> {
     // A close arriving mid-boot must still close what that boot produced,
     // or `session_shutdown` during a slow start leaks the whole stack.
@@ -232,8 +161,6 @@ export class WebWorkspaceController {
     const session = this.session;
     if (session === null) return;
     this.session = null;
-    // `server.close()` closes the hub and awaits the watcher — it was handed
-    // both at construction and owns their teardown (server.ts §5.4).
     await session.server.close();
     this.deps.onStateChange?.();
   }
@@ -258,34 +185,14 @@ export class WebWorkspaceController {
     const cwd = ctx.cwd;
     const vaultRoot = (this.deps.vaultRoot ?? resolveVaultRoot)();
     const cache = new WorkspaceCache({ cwd, vaultRoot });
-    const sse = new SseHub({ currentStamp: () => liveness.currentStamp() });
-    const liveness = createLivenessBridge(cache, sse);
-
-    const watcher = new Watcher({
-      cwd,
-      vaultRoot,
-      // Per-path, immediately: eviction wants every path (§6).
-      onPath: (absPath) => liveness.onPath(absPath),
-      // Per debounce window: one frame per scope, whatever the path count.
-      onChange: (scopes) => liveness.onChange(scopes),
-    });
-
     const startServer = this.deps.startServer ?? startWorkspaceServer;
     const server = await startServer({
       cwd,
       vaultRoot,
       cache,
-      sse,
-      watcher: asServerWatcher(watcher),
-      // The idle timeout closed the server behind our back; forget it so the
-      // next `/weave-view` boots a fresh one instead of handing out a dead port.
-      onIdleShutdown: () => {
-        this.session = null;
-        this.deps.onStateChange?.();
-      },
     });
 
-    return { server, cache, sse, watcher, liveness };
+    return { server, cache };
   }
 
   /** Spawn the browser, reporting failure rather than throwing it. */
@@ -303,23 +210,6 @@ export class WebWorkspaceController {
   }
 }
 
-/**
- * Adapt the concrete {@link Watcher} to the promise-shaped contract
- * `server.ts` owns. The class is synchronous because `fs.watch` is; the
- * interface is async because a future watcher (a `chokidar`-style poller, a
- * remote FS) would not be.
- */
-function asServerWatcher(watcher: Watcher): ServerWatcher {
-  return {
-    start: async () => {
-      watcher.start();
-    },
-    close: async () => {
-      watcher.close();
-    },
-  };
-}
-
 /** The one notification, worded for whichever path got us here. */
 function describe(facts: { url: string; started: boolean; opened: boolean; wantsBrowser: boolean }): string {
   const where = facts.started ? "workspace running at" : "workspace already running at";

package/src/web/client/api.dom.ts

@@ -10,8 +10,7 @@
  * Something still has to call the real thing. That is this file, and it is
  * separate so the untestable surface — one reference to a DOM global — is
  * isolated in four lines rather than smeared through the module that holds
- * all the request logic. Same shape as `domEventSource` in `live.ts`, for the
- * same reason.
+ * all the request logic.
  *
  * This module is only reachable from `.tsx` entry points, so it is compiled
  * by `tsconfig.web.json` (which has `DOM`) and never pulled into the root
@@ -32,6 +31,7 @@ export const fetchJson: FetchLike = (url: string, init?: HttpRequest): Promise<H
     ...(init?.method === undefined ? {} : { method: init.method }),
     ...(init?.headers === undefined ? {} : { headers: init.headers }),
     ...(init?.body === undefined ? {} : { body: init.body }),
+    ...(init?.signal === undefined ? {} : { signal: init.signal as AbortSignal }),
     // Loopback only, and the `__Host-weave` cookie is how §5.1 authenticates.
     // `same-origin` is the default in modern browsers; stated explicitly
     // because the whole security model depends on it and a default is a worse