@nuvin/session 0.1.0-rc.5

package/dist/test-utils/fake-relay.d.ts

@@ -0,0 +1,24 @@
+import { PROTOCOL_VERSION } from "../protocol/index.ts";
+/**
+ * Scripted stand-in for the @nuvin/server relay (extraction spec §4 stage 1c):
+ * exactly the REST + WS surface the CLIENT-side tests exercise — device-code
+ * registration, daemon list/connect/revoke, /control + /tunnel/:id +
+ * /connect/:id with a byte-splice. Auth mirrors the relay's StubTokenVerifier
+ * (`Bearer test:<userId>`). Grants are REAL (signGrant) so the daemon verifies
+ * them end-to-end. Live daemon↔relay e2e against the real relay lives in the
+ * nuvin-server repo — this fake exists so client tests never import it.
+ */
+export type FakeRelay = {
+    base: string;
+    port: number;
+    publicKey: string;
+    protocolVersion: typeof PROTOCOL_VERSION;
+    isOnline(daemonId: string): boolean;
+    /** Close every live channel socket pair — simulates a relay restart. */
+    closeAllChannels(): void;
+    close(): Promise<void>;
+};
+export declare function startFakeRelay(options?: {
+    grantTtlMs?: number;
+}): Promise<FakeRelay>;
+//# sourceMappingURL=fake-relay.d.ts.map

package/dist/test-utils/fake-relay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-relay.d.ts","sourceRoot":"","sources":["../../src/test-utils/fake-relay.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGxD;;;;;;;;GAQG;AAEH,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,OAAO,gBAAgB,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,wEAAwE;IACxE,gBAAgB,IAAI,IAAI,CAAC;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAgDF,wBAAsB,cAAc,CAAC,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CAwO9F"}

package/dist/test-utils/index.d.ts

@@ -0,0 +1,2 @@
+export { type FakeRelay, startFakeRelay } from "./fake-relay.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/test-utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test-utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/test-utils/index.js

@@ -0,0 +1,250 @@
+import "../chunk-DGC7JSCG.js";
+import {
+  PROTOCOL_VERSION
+} from "../chunk-7G3R25NS.js";
+import {
+  generateGrantKeyPair,
+  signGrant
+} from "../chunk-3IPZO7LP.js";
+
+// src/test-utils/fake-relay.ts
+import { randomUUID } from "crypto";
+import { once } from "events";
+import {
+  createServer
+} from "http";
+import { WebSocket, WebSocketServer } from "ws";
+var userIdFromAuth = (request) => {
+  const header = request.headers.authorization;
+  if (typeof header !== "string" || !header.startsWith("Bearer test:")) return null;
+  const userId = header.slice("Bearer test:".length);
+  return userId.length > 0 ? userId : null;
+};
+var sendJson = (res, status, body) => {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(body === void 0 ? void 0 : JSON.stringify(body));
+};
+var readJson = async (req) => {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  const text = Buffer.concat(chunks).toString("utf8");
+  return text ? JSON.parse(text) : {};
+};
+var rejectUpgrade = (socket, status, message) => {
+  socket.write(`HTTP/1.1 ${status} ${message}\r
+Connection: close\r
+\r
+`);
+  socket.destroy();
+};
+async function startFakeRelay(options = {}) {
+  const grantTtlMs = options.grantTtlMs ?? 6e4;
+  const keys = generateGrantKeyPair();
+  const daemons = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const controls = /* @__PURE__ */ new Map();
+  const channels = /* @__PURE__ */ new Map();
+  let port = 0;
+  let base = "";
+  const httpServer = createServer();
+  const wss = new WebSocketServer({ noServer: true });
+  const closeChannel = (channelId, code, reason) => {
+    const channel = channels.get(channelId);
+    if (!channel) return;
+    channels.delete(channelId);
+    channel.client?.close(code, reason);
+    channel.daemon?.close(code, reason);
+  };
+  const attachChannelSide = (channelId, side, ws) => {
+    const channel = channels.get(channelId);
+    if (!channel) {
+      ws.close(4404, "unknown-channel");
+      return;
+    }
+    channel[side] = ws;
+    const outbound = side === "client" ? channel.forClient : channel.forDaemon;
+    const inbound = side === "client" ? channel.forDaemon : channel.forClient;
+    for (const frame of outbound.splice(0)) ws.send(frame.data, { binary: frame.isBinary });
+    ws.on("message", (data, isBinary) => {
+      const peer = side === "client" ? channel.daemon : channel.client;
+      if (peer && peer.readyState === WebSocket.OPEN) peer.send(data, { binary: isBinary });
+      else inbound.push({ data, isBinary });
+    });
+    ws.on("close", () => closeChannel(channelId, 1e3, "peer-closed"));
+  };
+  httpServer.on("request", (req, res) => {
+    void (async () => {
+      const url = new URL(req.url ?? "/", "http://fake.invalid");
+      const route = `${req.method} ${url.pathname}`;
+      if (route === "POST /api/device/code") {
+        const body = await readJson(req);
+        const entry = {
+          deviceCode: randomUUID(),
+          userCode: randomUUID().slice(0, 8),
+          daemonName: String(body.daemonName ?? "daemon"),
+          claimedBy: null
+        };
+        pending.set(entry.deviceCode, entry);
+        sendJson(res, 200, {
+          deviceCode: entry.deviceCode,
+          userCode: entry.userCode,
+          verificationUrl: `${base}/link`,
+          interval: 1,
+          expiresIn: 900
+        });
+        return;
+      }
+      if (route === "POST /api/device/claim") {
+        const userId = userIdFromAuth(req);
+        if (!userId) return sendJson(res, 401, { message: "unauthorized" });
+        const body = await readJson(req);
+        const entry = [...pending.values()].find((p) => p.userCode === body.userCode);
+        if (!entry) return sendJson(res, 404, { message: "unknown user code" });
+        entry.claimedBy = userId;
+        sendJson(res, 200, { daemonName: entry.daemonName });
+        return;
+      }
+      if (route === "POST /api/device/token") {
+        const body = await readJson(req);
+        const entry = pending.get(String(body.deviceCode));
+        if (!entry) return sendJson(res, 404, { message: "unknown device code" });
+        if (!entry.claimedBy) return sendJson(res, 200, { status: "pending" });
+        pending.delete(entry.deviceCode);
+        const row = {
+          id: randomUUID(),
+          name: entry.daemonName,
+          deviceToken: randomUUID(),
+          userId: entry.claimedBy,
+          revoked: false
+        };
+        daemons.set(row.id, row);
+        sendJson(res, 200, {
+          status: "complete",
+          daemonId: row.id,
+          deviceToken: row.deviceToken,
+          serverPublicKey: keys.publicKey,
+          serverUrl: base
+        });
+        return;
+      }
+      if (route === "GET /api/daemons") {
+        const userId = userIdFromAuth(req);
+        if (!userId) return sendJson(res, 401, { message: "unauthorized" });
+        const rows = [...daemons.values()].filter((row) => row.userId === userId && !row.revoked).map((row) => ({
+          id: row.id,
+          name: row.name,
+          online: controls.has(row.id),
+          lastSeenAt: null,
+          sessions: []
+        }));
+        sendJson(res, 200, rows);
+        return;
+      }
+      const connectMatch = /^POST \/api\/daemons\/([A-Za-z0-9_-]+)\/connect$/.exec(route);
+      if (connectMatch?.[1]) {
+        const userId = userIdFromAuth(req);
+        if (!userId) return sendJson(res, 401, { message: "unauthorized" });
+        const row = daemons.get(connectMatch[1]);
+        if (!row || row.revoked || row.userId !== userId) {
+          return sendJson(res, 404, { message: "unknown daemon" });
+        }
+        const control = controls.get(row.id);
+        if (!control) return sendJson(res, 409, { message: "daemon-offline" });
+        const channelId = randomUUID();
+        channels.set(channelId, {
+          daemonId: row.id,
+          client: null,
+          daemon: null,
+          forDaemon: [],
+          forClient: []
+        });
+        const issuedAt = Date.now();
+        const payload = {
+          daemonId: row.id,
+          userId,
+          grantId: randomUUID(),
+          issuedAt,
+          expiresAt: issuedAt + grantTtlMs
+        };
+        control.send(JSON.stringify({ type: "open-channel", channelId }));
+        sendJson(res, 200, {
+          wsUrl: `ws://127.0.0.1:${port}/connect/${channelId}`,
+          grant: signGrant(payload, keys.privateKey)
+        });
+        return;
+      }
+      const revokeMatch = /^DELETE \/api\/daemons\/([A-Za-z0-9_-]+)$/.exec(route);
+      if (revokeMatch?.[1]) {
+        const userId = userIdFromAuth(req);
+        if (!userId) return sendJson(res, 401, { message: "unauthorized" });
+        const row = daemons.get(revokeMatch[1]);
+        if (!row || row.userId !== userId) return sendJson(res, 404, { message: "unknown daemon" });
+        row.revoked = true;
+        const control = controls.get(row.id);
+        control?.send(JSON.stringify({ type: "revoked" }));
+        control?.close(1e3, "revoked");
+        for (const [channelId, channel] of channels) {
+          if (channel.daemonId === row.id) closeChannel(channelId, 1e3, "revoked");
+        }
+        sendJson(res, 204);
+        return;
+      }
+      sendJson(res, 404, { message: "not found" });
+    })().catch(() => sendJson(res, 500, { message: "fake relay error" }));
+  });
+  httpServer.on("upgrade", (request, socket, head) => {
+    const pathname = new URL(request.url ?? "/", "http://fake.invalid").pathname;
+    if (pathname === "/control") {
+      const header = request.headers.authorization;
+      const token = typeof header === "string" && header.startsWith("Bearer ") ? header.slice(7) : null;
+      const row = token ? [...daemons.values()].find((d) => d.deviceToken === token && !d.revoked) : void 0;
+      if (!row) {
+        rejectUpgrade(socket, 401, "Unauthorized");
+        return;
+      }
+      wss.handleUpgrade(request, socket, head, (ws) => {
+        controls.set(row.id, ws);
+        ws.on("close", () => {
+          if (controls.get(row.id) === ws) controls.delete(row.id);
+        });
+      });
+      return;
+    }
+    const connect = /^\/connect\/([A-Za-z0-9_-]+)$/.exec(pathname);
+    if (connect?.[1]) {
+      const channelId = connect[1];
+      wss.handleUpgrade(request, socket, head, (ws) => attachChannelSide(channelId, "client", ws));
+      return;
+    }
+    const tunnel = /^\/tunnel\/([A-Za-z0-9_-]+)$/.exec(pathname);
+    if (tunnel?.[1]) {
+      const channelId = tunnel[1];
+      wss.handleUpgrade(request, socket, head, (ws) => attachChannelSide(channelId, "daemon", ws));
+      return;
+    }
+    rejectUpgrade(socket, 404, "Not Found");
+  });
+  httpServer.listen(0, "127.0.0.1");
+  await once(httpServer, "listening");
+  const address = httpServer.address();
+  port = typeof address === "object" && address !== null ? address.port : 0;
+  base = `http://127.0.0.1:${port}`;
+  return {
+    base,
+    port,
+    publicKey: keys.publicKey,
+    protocolVersion: PROTOCOL_VERSION,
+    isOnline: (daemonId) => controls.has(daemonId),
+    closeAllChannels: () => {
+      for (const channelId of [...channels.keys()]) closeChannel(channelId, 1012, "relay-restart");
+    },
+    close: () => new Promise((resolve) => {
+      for (const client of wss.clients) client.terminate();
+      httpServer.closeAllConnections?.();
+      wss.close(() => httpServer.close(() => resolve()));
+    })
+  };
+}
+export {
+  startFakeRelay
+};

package/dist/ui/history-grouping.d.ts

@@ -0,0 +1,36 @@
+import type { HistorySummary } from "../protocol/types.ts";
+/**
+ * Case-insensitive subsequence match (the history search predicate). An empty
+ * query matches everything; an undefined value never matches.
+ */
+export declare function fuzzyIncludes(value: string | undefined, query: string): boolean;
+/** Epoch ms truncated to local midnight. */
+export declare function startOfDay(value: number): number;
+/**
+ * Date-bucket label for a history row. Does NOT collapse every older date to a
+ * bare weekday name (which repeats week-over-week and reads as ambiguous).
+ * Scheme:
+ *   - Today / Yesterday
+ *   - within the last 7 days → weekday name (unambiguous inside one week)
+ *   - older → absolute date ("Jun 8", or "Jun 8, 2025" when the year differs)
+ */
+export declare function groupLabel(updatedAt: number, now?: number): string;
+/**
+ * Relative timestamp for a history row. Today → "Just now" / "Nm ago" / "Nh
+ * ago"; previous days → "Nd ago" / "Nw ago" (capped at 5 weeks, then falls back
+ * to the absolute date so a 3-month-old session doesn't read "13w ago").
+ */
+export declare function formatSessionTime(updatedAt: number, now?: number): string;
+/**
+ * Fuzzy-filter a daemon's cold-session list by title or id. A blank/whitespace
+ * query returns the list unchanged. Mirrors the history view's search predicate.
+ */
+export declare function filterHistory(items: HistorySummary[], query: string): HistorySummary[];
+/**
+ * Select + order history rows for display (spec §7). Without showAll and with a
+ * known currentWorkspace, restrict to that workspace (the local-TUI default).
+ * Otherwise show every workspace, ordering the current workspace's rows first,
+ * then by recency. Web/remote (no currentWorkspace) always see everything.
+ */
+export declare function visibleHistory(items: HistorySummary[], currentWorkspace: string | undefined, showAll: boolean): HistorySummary[];
+//# sourceMappingURL=history-grouping.d.ts.map

package/dist/ui/history-grouping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history-grouping.d.ts","sourceRoot":"","sources":["../../src/ui/history-grouping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAI3D;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAc/E;AAED,4CAA4C;AAC5C,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,SAAa,GAAG,MAAM,CActE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,SAAa,GAAG,MAAM,CAqB7E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE,CAMtF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,cAAc,EAAE,EACvB,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,OAAO,EAAE,OAAO,GACf,cAAc,EAAE,CAalB"}

package/dist/ui/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./history-grouping.ts";
+export * from "./picker-rows.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ui/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC"}

package/dist/ui/index.js

@@ -0,0 +1,135 @@
+// src/ui/history-grouping.ts
+var DAY_MS = 864e5;
+function fuzzyIncludes(value, query) {
+  if (!value) return false;
+  let queryIndex = 0;
+  const normalizedValue = value.toLowerCase();
+  const normalizedQuery = query.toLowerCase();
+  for (const char of normalizedValue) {
+    if (char === normalizedQuery[queryIndex]) {
+      queryIndex += 1;
+      if (queryIndex === normalizedQuery.length) return true;
+    }
+  }
+  return normalizedQuery.length === 0;
+}
+function startOfDay(value) {
+  const date = new Date(value);
+  date.setHours(0, 0, 0, 0);
+  return date.getTime();
+}
+function groupLabel(updatedAt, now = Date.now()) {
+  const day = startOfDay(updatedAt);
+  const today = startOfDay(now);
+  if (day === today) return "Today";
+  if (day === today - DAY_MS) return "Yesterday";
+  if (day > today - 7 * DAY_MS) {
+    return new Date(updatedAt).toLocaleDateString(void 0, { weekday: "long" });
+  }
+  const sameYear = new Date(updatedAt).getFullYear() === new Date(now).getFullYear();
+  return new Date(updatedAt).toLocaleDateString(void 0, {
+    month: "short",
+    day: "numeric",
+    ...sameYear ? {} : { year: "numeric" }
+  });
+}
+function formatSessionTime(updatedAt, now = Date.now()) {
+  const diffMs = Math.max(0, now - updatedAt);
+  if (diffMs < 6e4) return "Just now";
+  const days = Math.floor(diffMs / DAY_MS);
+  if (days === 0) {
+    const hours = Math.floor(diffMs / 36e5);
+    if (hours > 0) return `${hours}h ago`;
+    return `${Math.max(1, Math.floor(diffMs / 6e4))}m ago`;
+  }
+  if (days === 1) return "1d ago";
+  if (days < 7) return `${days}d ago`;
+  const weeks = Math.floor(days / 7);
+  if (weeks === 1) return "1w ago";
+  if (weeks <= 5) return `${weeks}w ago`;
+  const sameYear = new Date(updatedAt).getFullYear() === new Date(now).getFullYear();
+  return new Date(updatedAt).toLocaleDateString(void 0, {
+    month: "short",
+    day: "numeric",
+    ...sameYear ? {} : { year: "numeric" }
+  });
+}
+function filterHistory(items, query) {
+  const needle = query.trim().toLowerCase();
+  if (!needle) return items;
+  return items.filter(
+    (item) => fuzzyIncludes(item.title, needle) || fuzzyIncludes(item.id, needle)
+  );
+}
+function visibleHistory(items, currentWorkspace, showAll) {
+  const scoped = !showAll && currentWorkspace ? items.filter((item) => item.workspace === currentWorkspace) : items;
+  return [...scoped].sort((a, b) => {
+    if (currentWorkspace) {
+      const aCur = a.workspace === currentWorkspace ? 0 : 1;
+      const bCur = b.workspace === currentWorkspace ? 0 : 1;
+      if (aCur !== bCur) return aCur - bCur;
+    }
+    return b.updatedAt - a.updatedAt;
+  });
+}
+
+// src/ui/picker-rows.ts
+function isSelectable(row) {
+  return row.kind !== "header" && row.kind !== "status";
+}
+function buildPickerRows(input) {
+  const rows = [];
+  for (const server of input.directory.servers) {
+    rows.push({ kind: "header", label: server.name });
+    if (server.status.state === "connecting") {
+      rows.push({ kind: "status", text: "connecting\u2026" });
+      continue;
+    }
+    if (server.status.state === "offline") {
+      rows.push({ kind: "status", text: `offline \u2014 ${server.status.error}` });
+      continue;
+    }
+    rows.push({ kind: "new", server: server.name });
+    const sessions = [...server.status.sessions].sort(
+      (a, b) => b.lastActivityAt - a.lastActivityAt
+    );
+    for (const session of sessions) {
+      rows.push({ kind: "session", server: server.name, session });
+    }
+    rows.push({ kind: "history", server: server.name });
+  }
+  for (const issue of input.issues) {
+    rows.push({ kind: "header", label: issue.name });
+    rows.push({ kind: "status", text: `offline \u2014 ${issue.message}` });
+  }
+  return rows;
+}
+function selectableIndices(rows) {
+  const indices = [];
+  rows.forEach((row, index) => {
+    if (isSelectable(row)) indices.push(index);
+  });
+  return indices;
+}
+function sessionTitle(session) {
+  return session.topic ?? session.lastMessage ?? session.name;
+}
+function describeSession(session) {
+  const clients = `${session.attachedClients} client${session.attachedClients === 1 ? "" : "s"}`;
+  const label = sessionTitle(session);
+  const workspaceTag = session.workspace && session.workspace !== "default" ? ` [${session.workspace}]` : "";
+  return `${label}${workspaceTag} \xB7 ${session.status} \xB7 ${session.cwd} \xB7 ${clients}`;
+}
+export {
+  buildPickerRows,
+  describeSession,
+  filterHistory,
+  formatSessionTime,
+  fuzzyIncludes,
+  groupLabel,
+  isSelectable,
+  selectableIndices,
+  sessionTitle,
+  startOfDay,
+  visibleHistory
+};

package/dist/ui/picker-rows.d.ts

@@ -0,0 +1,62 @@
+import type { DirectoryView } from "../client/directory.ts";
+import type { SessionDescriptor } from "../protocol/types.ts";
+/**
+ * A configured-server entry that could not be resolved, with an actionable
+ * reason. The picker renders these as offline(error) sections; they never block
+ * anything. Structurally identical to the CLI's `ServerResolutionIssue`, defined
+ * locally so this module stays dependency-free (consumable by TUI and web).
+ */
+export type PickerIssue = {
+    name: string;
+    message: string;
+};
+/**
+ * Uniform dashboard row model (spec §4). One section per daemon (Local +
+ * configured servers): a header, then either a connecting/offline status row,
+ * or — when online — a New-session row, the daemon's live sessions, and a
+ * single History entry-point row that opens the per-daemon history view WITHOUT
+ * entering a session. There are NO resumable-history rows in the dashboard
+ * (history lives in the history view).
+ */
+export type PickerRow = {
+    kind: "header";
+    label: string;
+} | {
+    kind: "status";
+    text: string;
+} | {
+    kind: "new";
+    server: string;
+} | {
+    kind: "session";
+    server: string;
+    session: SessionDescriptor;
+} | {
+    kind: "history";
+    server: string;
+};
+export declare function isSelectable(row: PickerRow): boolean;
+export type BuildPickerRowsInput = {
+    directory: DirectoryView;
+    issues: PickerIssue[];
+};
+/**
+ * Pure dashboard content model (spec §4). For each daemon in the directory:
+ * a header with the daemon name, then its connection status. An online daemon
+ * shows a New-session row, its live sessions (most-recently-active first), and
+ * a History entry-point row. A connecting/offline daemon shows only a status
+ * row (offline → sessions unknown). Unresolvable config entries (issues) render
+ * as offline sections after the connected daemons.
+ */
+export declare function buildPickerRows(input: BuildPickerRowsInput): PickerRow[];
+/** Indices into `rows` for selectable rows, in display order. */
+export declare function selectableIndices(rows: PickerRow[]): number[];
+/**
+ * Display title for a live session (spec §4): the human-readable topic when
+ * set, else the first line of the most recent user message, else the
+ * (id-derived) session name. Shared by the TUI dashboard and the web client.
+ */
+export declare function sessionTitle(session: SessionDescriptor): string;
+/** One-line live-session summary: title [workspace] · status · cwd · attached clients (spec §4). */
+export declare function describeSession(session: SessionDescriptor): string;
+//# sourceMappingURL=picker-rows.d.ts.map

package/dist/ui/picker-rows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"picker-rows.d.ts","sourceRoot":"","sources":["../../src/ui/picker-rows.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,GACjB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,iBAAiB,CAAA;CAAE,GAC/D;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAExC,wBAAgB,YAAY,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAEpD;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,aAAa,CAAC;IACzB,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,SAAS,EAAE,CA6BxE;AAED,iEAAiE;AACjE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,MAAM,EAAE,CAM7D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAE/D;AAED,oGAAoG;AACpG,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAQlE"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@nuvin/session",
+  "version": "0.1.0-rc.5",
+  "private": false,
+  "description": "Headless session layer for Nuvin: state reducers, wire protocol, session controller",
+  "license": "Apache-2.0",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    "./state": {
+      "types": "./dist/state/index.d.ts",
+      "import": "./dist/state/index.js"
+    },
+    "./tool-preview": {
+      "types": "./dist/state/tool-preview.d.ts",
+      "import": "./dist/state/tool-preview.js"
+    },
+    "./protocol": {
+      "types": "./dist/protocol/index.d.ts",
+      "import": "./dist/protocol/index.js"
+    },
+    "./controller": {
+      "types": "./dist/controller/index.d.ts",
+      "import": "./dist/controller/index.js"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js"
+    },
+    "./grant": {
+      "types": "./dist/grant/index.d.ts",
+      "import": "./dist/grant/index.js"
+    },
+    "./ui": {
+      "types": "./dist/ui/index.d.ts",
+      "import": "./dist/ui/index.js"
+    },
+    "./test-utils": {
+      "types": "./dist/test-utils/index.d.ts",
+      "import": "./dist/test-utils/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup && tsc -p tsconfig.build.json --emitDeclarationOnly",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist",
+    "lint": "biome check ."
+  },
+  "dependencies": {
+    "@nuvin/agent-core": "workspace:^",
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.1",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  }
+}