@hydra-acp/cli 0.1.59 → 0.1.61

package/dist/index.d.ts

@@ -156,6 +156,7 @@ declare const HydraConfig: z.ZodObject<{
         maxToolItems: z.ZodDefault<z.ZodNumber>;
         maxPlanItems: z.ZodDefault<z.ZodNumber>;
         showFileUpdates: z.ZodDefault<z.ZodEnum<["none", "edit", "diff"]>>;
+        sessionColumns: z.ZodOptional<z.ZodArray<z.ZodEnum<["session", "upstream", "host", "state", "agent", "model", "age", "cwd", "title", "cost"]>, "atleastone">>;
     }, "strip", z.ZodTypeAny, {
         repaintThrottleMs: number;
         maxScrollbackLines: number;
@@ -169,6 +170,7 @@ declare const HydraConfig: z.ZodObject<{
         maxToolItems: number;
         maxPlanItems: number;
         showFileUpdates: "diff" | "none" | "edit";
+        sessionColumns?: ["agent" | "model" | "cwd" | "session" | "upstream" | "state" | "age" | "title" | "host" | "cost", ...("agent" | "model" | "cwd" | "session" | "upstream" | "state" | "age" | "title" | "host" | "cost")[]] | undefined;
     }, {
         repaintThrottleMs?: number | undefined;
         maxScrollbackLines?: number | undefined;
@@ -182,6 +184,7 @@ declare const HydraConfig: z.ZodObject<{
         maxToolItems?: number | undefined;
         maxPlanItems?: number | undefined;
         showFileUpdates?: "diff" | "none" | "edit" | undefined;
+        sessionColumns?: ["agent" | "model" | "cwd" | "session" | "upstream" | "state" | "age" | "title" | "host" | "cost", ...("agent" | "model" | "cwd" | "session" | "upstream" | "state" | "age" | "title" | "host" | "cost")[]] | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     tui: {
@@ -197,6 +200,7 @@ declare const HydraConfig: z.ZodObject<{
         maxToolItems: number;
         maxPlanItems: number;
         showFileUpdates: "diff" | "none" | "edit";
+        sessionColumns?: ["agent" | "model" | "cwd" | "session" | "upstream" | "state" | "age" | "title" | "host" | "cost", ...("agent" | "model" | "cwd" | "session" | "upstream" | "state" | "age" | "title" | "host" | "cost")[]] | undefined;
     };
     daemon: {
         host: string;
@@ -251,6 +255,7 @@ declare const HydraConfig: z.ZodObject<{
         maxToolItems?: number | undefined;
         maxPlanItems?: number | undefined;
         showFileUpdates?: "diff" | "none" | "edit" | undefined;
+        sessionColumns?: ["agent" | "model" | "cwd" | "session" | "upstream" | "state" | "age" | "title" | "host" | "cost", ...("agent" | "model" | "cwd" | "session" | "upstream" | "state" | "age" | "title" | "host" | "cost")[]] | undefined;
     } | undefined;
     daemon?: {
         host?: string | undefined;
@@ -1419,6 +1424,8 @@ declare const SessionAttachParams: z.ZodObject<{
         version?: string | undefined;
     }>>;
     readonly: z.ZodOptional<z.ZodBoolean>;
+    replayMode: z.ZodOptional<z.ZodEnum<["instant", "drip"]>>;
+    dripSpeed: z.ZodOptional<z.ZodNumber>;
     _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     sessionId: string;
@@ -1430,6 +1437,8 @@ declare const SessionAttachParams: z.ZodObject<{
     } | undefined;
     afterMessageId?: string | undefined;
     clientId?: string | undefined;
+    replayMode?: "drip" | "instant" | undefined;
+    dripSpeed?: number | undefined;
     _meta?: Record<string, unknown> | undefined;
 }, {
     sessionId: string;
@@ -1441,6 +1450,8 @@ declare const SessionAttachParams: z.ZodObject<{
     historyPolicy?: "none" | "full" | "pending_only" | "after_message" | undefined;
     afterMessageId?: string | undefined;
     clientId?: string | undefined;
+    replayMode?: "drip" | "instant" | undefined;
+    dripSpeed?: number | undefined;
     _meta?: Record<string, unknown> | undefined;
 }>;
 type SessionAttachParams = z.infer<typeof SessionAttachParams>;
@@ -1518,6 +1529,7 @@ declare const SessionListEntry: z.ZodObject<{
     attachedClients: z.ZodNumber;
     status: z.ZodDefault<z.ZodEnum<["live", "cold"]>>;
     busy: z.ZodDefault<z.ZodBoolean>;
+    awaitingInput: z.ZodDefault<z.ZodBoolean>;
     _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     sessionId: string;
@@ -1526,9 +1538,10 @@ declare const SessionListEntry: z.ZodObject<{
     updatedAt: string;
     attachedClients: number;
     busy: boolean;
+    awaitingInput: boolean;
+    title?: string | undefined;
     agentId?: string | undefined;
     upstreamSessionId?: string | undefined;
-    title?: string | undefined;
     _meta?: Record<string, unknown> | undefined;
     currentModel?: string | undefined;
     currentUsage?: {
@@ -1553,9 +1566,9 @@ declare const SessionListEntry: z.ZodObject<{
     updatedAt: string;
     attachedClients: number;
     status?: "live" | "cold" | undefined;
+    title?: string | undefined;
     agentId?: string | undefined;
     upstreamSessionId?: string | undefined;
-    title?: string | undefined;
     _meta?: Record<string, unknown> | undefined;
     currentModel?: string | undefined;
     currentUsage?: {
@@ -1575,6 +1588,7 @@ declare const SessionListEntry: z.ZodObject<{
         version?: string | undefined;
     } | undefined;
     busy?: boolean | undefined;
+    awaitingInput?: boolean | undefined;
 }>;
 type SessionListEntry = z.infer<typeof SessionListEntry>;
 declare const SessionListResult: z.ZodObject<{
@@ -2197,10 +2211,12 @@ declare class Session {
         version?: string;
     }>;
     get turnStartedAt(): number | undefined;
+    get awaitingInput(): boolean;
     getHistorySnapshot(): Promise<CachedNotification[]>;
     onBroadcast(handler: (entry: CachedNotification) => void): () => void;
     attach(client: AttachedClient, historyPolicy: HistoryPolicy, opts?: {
         afterMessageId?: string;
+        raw?: boolean;
     }): Promise<{
         entries: CachedNotification[];
         appliedPolicy: HistoryPolicy;
@@ -2276,6 +2292,7 @@ declare class Session {
     private handleSessionsCommand;
     private handleHelpCommand;
     private handleModelCommand;
+    private handleModeCommand;
     private runTitleCommand;
     private runInternalPrompt;
     private runAgentCommand;
@@ -2710,8 +2727,8 @@ declare const Bundle: z.ZodObject<{
         updatedAt: string;
         createdAt: string;
         lineageId: string;
-        upstreamSessionId?: string | undefined;
         title?: string | undefined;
+        upstreamSessionId?: string | undefined;
         currentModel?: string | undefined;
         currentMode?: string | undefined;
         currentUsage?: {
@@ -2751,8 +2768,8 @@ declare const Bundle: z.ZodObject<{
         updatedAt: string;
         createdAt: string;
         lineageId: string;
-        upstreamSessionId?: string | undefined;
         title?: string | undefined;
+        upstreamSessionId?: string | undefined;
         currentModel?: string | undefined;
         currentMode?: string | undefined;
         currentUsage?: {
@@ -2809,8 +2826,8 @@ declare const Bundle: z.ZodObject<{
         updatedAt: string;
         createdAt: string;
         lineageId: string;
-        upstreamSessionId?: string | undefined;
         title?: string | undefined;
+        upstreamSessionId?: string | undefined;
         currentModel?: string | undefined;
         currentMode?: string | undefined;
         currentUsage?: {
@@ -2865,8 +2882,8 @@ declare const Bundle: z.ZodObject<{
         updatedAt: string;
         createdAt: string;
         lineageId: string;
-        upstreamSessionId?: string | undefined;
         title?: string | undefined;
+        upstreamSessionId?: string | undefined;
         currentModel?: string | undefined;
         currentMode?: string | undefined;
         currentUsage?: {

package/dist/index.js

@@ -293,7 +293,7 @@ var TuiConfig = z.object({
   // Width cap on the cwd column in the `sessions list` output and the
   // TUI picker. Set higher if you keep deeply-nested working directories
   // and want them visible; the elastic title column shrinks to make room.
-  cwdColumnMaxWidth: z.number().int().positive().default(24),
+  cwdColumnMaxWidth: z.number().int().positive().default(32),
   // When true (default), emit OSC 9;4 progress-bar control codes so the
   // host terminal can show an indeterminate busy indicator (taskbar pulse
   // on Windows Terminal, dock badge on KDE/Konsole, etc.) while a turn is
@@ -344,7 +344,28 @@ var TuiConfig = z.object({
   // The diff payload is extracted from the ACP wire (content[]
   // type:"diff" entries, falling back to rawInput shapes), so any agent
   // that emits one of those shapes gets the treatment.
-  showFileUpdates: z.enum(["none", "edit", "diff"]).default("edit")
+  showFileUpdates: z.enum(["none", "edit", "diff"]).default("edit"),
+  // Columns shown in the `sessions list` output and the TUI picker, in
+  // the given order — so this controls both which columns appear and
+  // their left-to-right order. Valid names: session, upstream, host,
+  // state, agent, model, age, cwd, title, cost. Omit to use the built-in
+  // default (session, state, agent, age, cwd, title, cost — UPSTREAM,
+  // HOST, and MODEL hidden). The CLI's `--columns` flag overrides this
+  // per-invocation. Duplicate or unknown names are rejected.
+  sessionColumns: z.array(
+    z.enum([
+      "session",
+      "upstream",
+      "host",
+      "state",
+      "agent",
+      "model",
+      "age",
+      "cwd",
+      "title",
+      "cost"
+    ])
+  ).nonempty().optional()
 });
 var ExtensionName = z.string().min(1).regex(/^[A-Za-z0-9._-]+$/, "extension name must be filename-safe");
 var ExtensionBody = z.object({
@@ -365,7 +386,7 @@ var TransformerBody = z.object({
 var HydraConfig = z.object({
   daemon: DaemonConfig.default({}),
   registry: RegistryConfig.default({ url: REGISTRY_URL_DEFAULT, ttlHours: 24 }),
-  defaultAgent: z.string().default("claude-acp"),
+  defaultAgent: z.string().default("opencode"),
   // Optional per-agent default model id. When a brand-new agent process
   // is spawned (session/new path), hydra issues session/set_model with
   // the matching entry so the user lands on their preferred model from
@@ -413,7 +434,7 @@ var HydraConfig = z.object({
     maxScrollbackLines: 1e4,
     mouse: false,
     logMaxBytes: 5 * 1024 * 1024,
-    cwdColumnMaxWidth: 24,
+    cwdColumnMaxWidth: 32,
     progressIndicator: true,
     defaultEnterAction: "amend",
     showThoughts: true,
@@ -1358,6 +1379,17 @@ var SessionAttachParams = z3.object({
   // to a cold session does not resurrect or spawn an agent — just
   // streams history from disk. Used by the TUI's view-only mode.
   readonly: z3.boolean().optional(),
+  // Debug-only replay pacing. When "drip", the daemon skips chunk
+  // coalescing and re-emits each recorded session/update individually,
+  // spacing them by their original recordedAt deltas (scaled by
+  // dripSpeed, with a per-gap cap) so a session's streaming render can
+  // be reproduced at its real granularity for flicker investigation.
+  // Omitted/"instant" preserves the normal coalesced, as-fast-as-possible
+  // replay.
+  replayMode: z3.enum(["instant", "drip"]).optional(),
+  // Multiplier applied to original inter-entry gaps in drip mode. >1
+  // compresses time (faster), <1 stretches it. Defaults to 1.
+  dripSpeed: z3.number().positive().optional(),
   _meta: z3.record(z3.unknown()).optional()
 });
 var HYDRA_META_KEY = "hydra-acp";
@@ -1586,6 +1618,11 @@ var SessionListEntry = z3.object({
   // Always false for cold sessions. Lets pickers render a busy dot
   // without having to attach.
   busy: z3.boolean().default(false),
+  // True when the agent is blocked on the user (an outstanding
+  // session/request_permission, which also covers agent-posed
+  // questions). Always false for cold sessions. Lets pickers render a
+  // distinct "waiting on you" glyph instead of the busy dot.
+  awaitingInput: z3.boolean().default(false),
   _meta: z3.record(z3.unknown()).optional()
 });
 var SessionListEntryWire = z3.object({
@@ -1603,7 +1640,8 @@ function sessionListEntryToWire(entry) {
   const hydraMeta = {
     attachedClients: entry.attachedClients,
     status: entry.status,
-    busy: entry.busy
+    busy: entry.busy,
+    awaitingInput: entry.awaitingInput
   };
   if (entry.agentId !== void 0) {
     hydraMeta.agentId = entry.agentId;
@@ -3324,6 +3362,14 @@ var Session = class {
   get turnStartedAt() {
     return this.promptStartedAt;
   }
+  // True when the agent is blocked on the user: an outstanding
+  // session/request_permission (which also carries agent-posed
+  // questions — there's no separate "ask the user" request in ACP).
+  // Lets pickers show a "waiting on you" glyph distinct from the
+  // "actively working" one without having to attach.
+  get awaitingInput() {
+    return this.inFlightPermissions.size > 0;
+  }
   // Read the persisted history from disk. Returns [] if no history
   // file exists (fresh session, never prompted). Used by attach() and
   // the HTTP /history endpoint.
@@ -3380,23 +3426,24 @@ var Session = class {
     return this.loadReplay(historyPolicy, opts);
   }
   async loadReplay(historyPolicy, opts) {
+    const maybeCoalesce = (entries) => opts.raw ? entries : coalesceReplay(entries);
     const raw = await this.getHistorySnapshot();
     const state = this.buildStateSnapshotReplay();
     if (historyPolicy === "after_message") {
       const cutoff = opts.afterMessageId ? findMessageIdIndex(raw, opts.afterMessageId) : -1;
       if (cutoff < 0) {
         return {
-          entries: [...state, ...coalesceReplay(raw)],
+          entries: [...state, ...maybeCoalesce(raw)],
           appliedPolicy: "full"
         };
       }
       return {
-        entries: [...state, ...coalesceReplay(raw.slice(cutoff + 1))],
+        entries: [...state, ...maybeCoalesce(raw.slice(cutoff + 1))],
         appliedPolicy: "after_message"
       };
     }
     return {
-      entries: [...state, ...coalesceReplay(raw)],
+      entries: [...state, ...maybeCoalesce(raw)],
       appliedPolicy: "full"
     };
   }
@@ -4663,6 +4710,7 @@ var Session = class {
     const out = [
       { name: "hydra", description: "Hydra session command (kill, restart, title, agent <agent>)" },
       { name: "model", description: "Switch model; omit arg to list available models" },
+      { name: "mode", description: "Switch mode; omit arg to list available modes" },
       { name: "sessions", description: "List all sessions" },
       { name: "help", description: "Show available commands" }
     ];
@@ -4933,6 +4981,60 @@ ${body}
     });
     return { stopReason: "end_turn" };
   }
+  // /mode — the text-command twin of session/set_mode, so clients that
+  // can only send prompts (e.g. Slack) can switch modes. With no arg it
+  // lists advertised modes; with an arg it forwards session/set_mode to
+  // the agent and then applies the change locally. The forward +
+  // applyModeChange pair MUST stay identical to the daemon's
+  // session/set_mode handler (see acp-ws.ts) — applyModeChange owns the
+  // persistence + synthetic current_mode_update broadcast for both paths.
+  async handleModeCommand(text) {
+    const arg = text.slice("/mode".length).trim();
+    if (arg === "") {
+      const modes2 = this.agentAdvertisedModes;
+      const current = this.currentMode;
+      let body;
+      if (modes2.length === 0) {
+        body = current ? `Current mode: ${current}` : "_(no modes advertised yet)_";
+      } else {
+        const inList = current ? modes2.some((m) => m.id === current) : true;
+        const lines = modes2.map((m) => {
+          const marker = m.id === current ? "\u25B6 " : "  ";
+          const desc = m.name && m.name !== m.id ? `  ${m.name}` : "";
+          return `${marker}${m.id}${desc}`;
+        });
+        if (!inList && current) {
+          lines.unshift(`\u25B6 ${current}`);
+        }
+        body = lines.join("\n");
+      }
+      this.recordAndBroadcast("session/update", {
+        sessionId: this.upstreamSessionId,
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: `
+${body}
+` },
+          _meta: { "hydra-acp": { synthetic: true } }
+        }
+      });
+      return { stopReason: "end_turn" };
+    }
+    const modes = this.agentAdvertisedModes;
+    if (modes.length > 0 && !modes.some((m) => m.id === arg)) {
+      const known = modes.map((m) => m.id).join(", ");
+      throw withCode(
+        new Error(`unknown mode: ${arg} (known: ${known})`),
+        JsonRpcErrorCodes.InvalidParams
+      );
+    }
+    await this.forwardRequest("session/set_mode", {
+      sessionId: this.sessionId,
+      modeId: arg
+    });
+    this.applyModeChange(arg);
+    return { stopReason: "end_turn" };
+  }
   // /hydra title. With an arg, sets the title directly (synchronous,
   // broadcasts session_info_update). Without an arg, asks the manager
   // to schedule a background synopsis via the ephemeral-agent path —
@@ -5758,12 +5860,14 @@ _(switched from \`${oldAgentId}\` to \`${newAgentId}\`)_
     }
     this.broadcastPromptReceived(entry);
     const promptText = extractPromptText(entry.prompt).trim();
-    if (promptText === "/model" || promptText.startsWith("/model ") || promptText === "/sessions" || promptText === "/help") {
+    if (promptText === "/model" || promptText.startsWith("/model ") || promptText === "/mode" || promptText.startsWith("/mode ") || promptText === "/sessions" || promptText === "/help") {
       let result;
       if (promptText === "/sessions") {
         result = await this.handleSessionsCommand();
       } else if (promptText === "/help") {
         result = await this.handleHelpCommand();
+      } else if (promptText === "/mode" || promptText.startsWith("/mode ")) {
+        result = await this.handleModeCommand(promptText);
       } else {
         result = await this.handleModelCommand(promptText);
       }
@@ -5825,7 +5929,12 @@ var STATE_UPDATE_KINDS = /* @__PURE__ */ new Set([
   "current_mode_update",
   "available_commands_update",
   "available_modes_update",
-  "usage_update"
+  "usage_update",
+  // opencode's non-spec carrier for model/mode/config state. Its canonical
+  // form is harvested into meta.json and re-synthesized on attach, so
+  // recording it would just give never-prompted sessions a non-empty
+  // history and make them look interactive in the picker.
+  "config_option_update"
 ]);
 function isStateUpdate(method, params) {
   if (method !== "session/update") {
@@ -7357,7 +7466,14 @@ var SessionManager = class {
       histories: this.histories,
       synopsisAgent: this.synopsisAgent,
       synopsisModel: this.synopsisModel,
-      persistTitle: (id, title) => this.persistTitle(id, title),
+      persistTitle: async (id, title) => {
+        const live = this.get(id);
+        if (live) {
+          await live.retitle(title);
+          return;
+        }
+        await this.persistTitle(id, title);
+      },
       persistSynopsis: (id, synopsis, through) => this.persistSynopsis(id, synopsis, through),
       logger: this.logger,
       npmRegistry: this.npmRegistry
@@ -7710,27 +7826,27 @@ var SessionManager = class {
       return false;
     }
   }
-  // When the last client detaches from a session that resolves to
-  // non-interactive — e.g. a `hydra cat` run, born interactive:undefined
-  // with originatingClient hydra-acp-cat, whose every prompt is ancillary
-  // — close it so its agent process doesn't linger until the (default 1h)
-  // idle timeout fires. The cold record is kept, so the rare refine-in-TUI
-  // still works via the resurrect/reseed path. Sessions promoted to
-  // interactive (driven by a real, non-ancillary prompt) resolve to true
-  // and are left running.
+  // When the last client detaches from a session that was never promoted
+  // to interactive, close it so its agent process doesn't linger until the
+  // (default 1h) idle timeout fires. This covers both `hydra cat` runs
+  // (born interactive:undefined with originatingClient hydra-acp-cat, every
+  // prompt ancillary) and any other client that opened a session but never
+  // sent a real, non-ancillary prompt. Promotion to interactive is
+  // synchronous on the first real prompt (Session.prompt sets _interactive
+  // = true before enqueuing), so a session that ever saw a genuine turn
+  // resolves to true here and is left running. The cold record is kept, so
+  // re-attaching resurrects via the reseed path.
+  //
+  // Note: this only fires from the explicit session/detach handler — raw WS
+  // close deliberately does NOT reap (see acp-ws.ts), so an abrupt
+  // disconnect of a never-prompted session falls through to the idle
+  // timeout rather than being torn down.
   async reapIfOrphanedNonInteractive(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session || session.attachedCount > 0) {
       return;
     }
-    const interactive = effectiveInteractive(
-      {
-        interactive: session.interactive,
-        ...session.originatingClient ? { originatingClient: session.originatingClient } : {}
-      },
-      true
-    );
-    if (interactive !== false) {
+    if (session.interactive === true) {
       return;
     }
     this.logger?.info(
@@ -8228,7 +8344,8 @@ var SessionManager = class {
         updatedAt: used,
         attachedClients: session.attachedCount,
         status: "live",
-        busy: session.turnStartedAt !== void 0
+        busy: session.turnStartedAt !== void 0,
+        awaitingInput: session.awaitingInput
       });
     }
     const records = await this.store.list().catch(() => []);
@@ -8266,7 +8383,8 @@ var SessionManager = class {
         updatedAt: used,
         attachedClients: 0,
         status: "cold",
-        busy: false
+        busy: false,
+        awaitingInput: false
       });
     }
     entries.sort((a, b) => a.updatedAt < b.updatedAt ? 1 : -1);
@@ -12663,10 +12781,11 @@ function registerAcpWsEndpoint(app, deps) {
         params.clientInfo,
         params.clientId
       );
+      const drip = params.replayMode === "drip";
       const { entries: replay, appliedPolicy } = await session.attach(
         client,
         params.historyPolicy,
-        { afterMessageId: params.afterMessageId }
+        { afterMessageId: params.afterMessageId, raw: drip }
       );
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
@@ -12674,10 +12793,35 @@ function registerAcpWsEndpoint(app, deps) {
         readonly
       });
       app.log.info(
-        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length} readonly=${readonly}`
+        `session/attach OK sessionId=${session.sessionId} clientId=${client.clientId} attachedCount=${state.attached.size} requestedPolicy=${params.historyPolicy} appliedPolicy=${appliedPolicy} replayed=${replay.length} readonly=${readonly}${drip ? " replayMode=drip" : ""}`
       );
-      for (const note of replay) {
-        await connection.notify(note.method, note.params);
+      if (drip) {
+        const speed = params.dripSpeed && params.dripSpeed > 0 ? params.dripSpeed : 1;
+        const MAX_GAP_MS = 750;
+        void (async () => {
+          let prev = null;
+          for (const note of replay) {
+            const at = typeof note.recordedAt === "number" ? note.recordedAt : null;
+            if (prev !== null && at !== null) {
+              const gap = Math.min(MAX_GAP_MS, Math.max(0, (at - prev) / speed));
+              if (gap > 0) {
+                await new Promise((r) => setTimeout(r, gap));
+              }
+            }
+            if (at !== null) {
+              prev = at;
+            }
+            try {
+              await connection.notify(note.method, note.params);
+            } catch {
+              return;
+            }
+          }
+        })();
+      } else {
+        for (const note of replay) {
+          await connection.notify(note.method, note.params);
+        }
       }
       session.replayPendingPermissions(client);
       const modesPayload = buildModesPayload(session);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hydra-acp/cli",
-  "version": "0.1.59",
+  "version": "0.1.61",
   "description": "Multi-client ACP session daemon: spawn agents, attach over WSS, multiplex sessions across editors.",
   "license": "MIT",
   "type": "module",