@hassangameryt/freeflow 0.7.3 → 0.9.0

package/pi-extension/dist/messaging/config.js

@@ -0,0 +1,27 @@
+export const DEFAULT_MESSAGING_ENABLED = false;
+export const DEFAULT_INBOUND_POLICY = "accept";
+export const INBOUND_POLICIES = ["accept", "project", "hold", "refuse"];
+const POLICIES = INBOUND_POLICIES;
+/** The keys `messaging` accepts; the settings test checks each has a /freeflow settings row. */
+export const MESSAGING_KEYS = ["enabled", "inbound"];
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function validateMessagingConfig(value) {
+  if (!record(value)) return "messaging must be an object";
+  const unknown = Object.keys(value).find((key) => !MESSAGING_KEYS.includes(key));
+  if (unknown) return `messaging has unsupported key: ${unknown}`;
+  if (value.enabled !== undefined && typeof value.enabled !== "boolean") return "messaging.enabled must be a boolean";
+  if (value.inbound !== undefined && !POLICIES.includes(value.inbound))
+    return `messaging.inbound must be one of ${POLICIES.join(", ")}`;
+  return null;
+}
+export function resolveMessagingConfig(repository, local, freeflowEnabled) {
+  const repositoryConfig = record(repository.messaging) ? repository.messaging : {};
+  const localConfig = record(local.messaging) ? local.messaging : {};
+  const pick = (key) => (Object.hasOwn(localConfig, key) ? localConfig[key] : repositoryConfig[key]);
+  const value = pick("enabled");
+  const enabled = value === undefined ? DEFAULT_MESSAGING_ENABLED : value === true;
+  const inbound = POLICIES.includes(pick("inbound")) ? pick("inbound") : DEFAULT_INBOUND_POLICY;
+  return { enabled, effective: freeflowEnabled && enabled, inbound };
+}

package/pi-extension/dist/messaging/messaging.js

@@ -0,0 +1,398 @@
+import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
+import { withoutNoticeTags } from "../host/inbound.js";
+import { LiveRegistry } from "./registry.js";
+import { close, listen, request, socketPathFor } from "./transport.js";
+/**
+ * Messaging between live Pi sessions on this machine (Task 002 D-005), following Claude Code's cross-session
+ * messaging: a session listens on its own socket while messaging is effective and lists itself in the live registry.
+ * A message from another session is delivered as a notice (steered in while busy, a new turn while idle), held for the
+ * user in a dialog that expires, or refused, by the inbound policy; the sender learns which. A message is information
+ * from another agent, never the user's instruction, and every delivered notice says so.
+ */
+export const MESSAGE_TYPE = "freeflow-message";
+export const MAX_MESSAGE_CHARS = 100_000;
+export const HOLD_EXPIRY_MS = 5 * 60_000;
+export const MAX_HELD = 100;
+/** A sender may send at most this many messages in BURST_WINDOW_MS. */
+export const BURST_LIMIT = 5;
+export const BURST_WINDOW_MS = 10_000;
+/** A receiver takes at most this many messages a minute from one sender, and this many in all. */
+export const PER_SENDER_PER_MINUTE = 20;
+export const ACCEPTED_PER_MINUTE = 50;
+export const WATCH_EXPIRY_MS = 12 * 60 * 60_000;
+const shortId = (sessionId) => sessionId.replace(/-/g, "").slice(-8);
+const attribute = (value) =>
+  value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/\n/g, " ");
+/** A message body cannot close its own tag, or pass for one of Freeflow's notices. */
+const escapeBody = (text) => withoutNoticeTags(text).replace(/<\/(message|message-status|session-status)/gi, "<\\/$1");
+export function displayName(identity) {
+  return identity.name?.trim() || `${basename(identity.cwd) || "session"}-${shortId(identity.sessionId).slice(0, 4)}`;
+}
+export class Messaging {
+  host;
+  registry;
+  server;
+  me;
+  busyNow = false;
+  writing = Promise.resolve();
+  stopping = false;
+  held = [];
+  asking = false;
+  watchers = new Map();
+  sent = [];
+  received = new Map();
+  accepted = [];
+  /** Display names of the sessions seen in the registry, for transcript rows. */
+  names = new Map();
+  holdExpiryMs;
+  constructor(host, home, options = {}) {
+    this.host = host;
+    this.registry = new LiveRegistry(home);
+    this.holdExpiryMs = options.holdExpiryMs ?? HOLD_EXPIRY_MS;
+  }
+  running() {
+    return this.server !== undefined;
+  }
+  self() {
+    return this.me;
+  }
+  heldCount() {
+    return this.held.length;
+  }
+  /** Listen and list this session; idempotent. Call again after the identity changes (name, focus) to refresh it. */
+  async start() {
+    const identity = await this.host.identity();
+    const socket = socketPathFor(identity.sessionId);
+    if (this.server && this.me?.sessionId !== identity.sessionId) await this.stop();
+    if (!this.server) this.server = await listen(socket, (body) => this.handle(body));
+    this.me = {
+      sessionId: identity.sessionId,
+      name: displayName(identity),
+      cwd: identity.cwd,
+      socket,
+      ...(identity.project ? { project: identity.project } : {}),
+      ...(identity.task ? { task: identity.task } : {}),
+      ...(identity.owns?.length ? { owns: identity.owns } : {}),
+    };
+    this.busyNow = this.host.busy();
+    await this.publish();
+  }
+  /** Session end or messaging off: tell watchers it exited, forget held messages, leave the registry. */
+  async stop() {
+    const me = this.me;
+    if (me) {
+      // No registry write starts from here on, and the one in flight lands before the entry is removed.
+      this.stopping = true;
+      await this.writing;
+      await this.notifyWatchers("exited");
+      await this.registry.remove(me.sessionId);
+      this.published = "";
+    }
+    for (const held of this.held.splice(0)) await this.outcome(held, "expired");
+    await close(this.server, me?.socket ?? "");
+    this.server = undefined;
+    this.me = undefined;
+    this.stopping = false;
+    this.watchers.clear();
+  }
+  /** The agent started or settled. Written only on change; turning idle notifies sessions waiting for it. */
+  async setBusy(busy) {
+    if (!this.me || busy === this.busyNow) return;
+    this.busyNow = busy;
+    await this.publish();
+    if (!busy) await this.notifyWatchers("idle");
+  }
+  async list() {
+    const sessions = await this.registry.list();
+    for (const session of sessions) this.names.set(session.sessionId, session.name);
+    return sessions;
+  }
+  /** The display name of a session this one has seen, for a row that has only its ID. */
+  nameOf(sessionId) {
+    return this.names.get(sessionId);
+  }
+  /**
+   * The live session with this session ID. Only a full ID addresses a session: names and folders are for display and
+   * may repeat (Task 002 D-009). An address that is not an ID gets the IDs it might mean, so the next call can use one.
+   */
+  async resolve(to) {
+    const address = to.trim();
+    if (address === this.me?.sessionId) return { error: "That is this session. Address another one." };
+    const sessions = (await this.list()).filter((session) => session.sessionId !== this.me?.sessionId);
+    const session = sessions.find((each) => each.sessionId === address);
+    if (session) return { session };
+    const compact = address.replace(/-/g, "");
+    const near = sessions.filter(
+      (each) =>
+        each.name === address ||
+        each.cwd === address ||
+        each.owns?.includes(address) ||
+        each.task === address ||
+        (compact.length >= 4 && each.sessionId.replace(/-/g, "").includes(compact)),
+    );
+    const how = "Address a session by its session ID, from list_sessions or the session= of a message it sent.";
+    return {
+      error: near.length
+        ? `"${to}" is not a session ID. ${how} Sessions it may mean: ${near.map((each) => `${each.name} (${each.sessionId})`).join(", ")}.`
+        : `No live session with messaging on has the session ID "${to}". ${how}`,
+    };
+  }
+  async send(to, text, options = {}) {
+    const me = this.me;
+    if (!me) return this.result(false, "Messaging is not running in this session.", {});
+    const body = typeof text === "string" ? text : "";
+    if (body.trim() === "") return this.result(false, "The message is empty.", {});
+    if (body.length > MAX_MESSAGE_CHARS)
+      return this.result(false, `The message has ${body.length} characters; the limit is ${MAX_MESSAGE_CHARS}.`, {});
+    const now = Date.now();
+    this.sent = this.sent.filter((at) => now - at < BURST_WINDOW_MS);
+    if (this.sent.length >= BURST_LIMIT)
+      return this.result(
+        false,
+        `Not sent: more than ${BURST_LIMIT} messages in ${BURST_WINDOW_MS / 1000} seconds. Wait for answers before sending more.`,
+        { status: "refused" },
+      );
+    const { session, error } = await this.resolve(to);
+    if (!session) return this.result(false, error ?? "No such session.", {});
+    this.sent.push(now);
+    const id = randomUUID();
+    let reply;
+    try {
+      reply = await request(session.socket, {
+        type: "message",
+        id,
+        from: me,
+        text: body,
+        ...(options.summary ? { summary: options.summary } : {}),
+      });
+    } catch (failure) {
+      return this.result(
+        false,
+        `Not delivered to ${session.name}: ${failure instanceof Error ? failure.message : String(failure)}`,
+        { to: session.sessionId, status: "failed" },
+      );
+    }
+    const status = String(reply?.status ?? "failed");
+    let watch = "";
+    if (options.notifyWhenIdle && (status === "delivered" || status === "held")) {
+      try {
+        const watched = await request(session.socket, { type: "watch", from: me });
+        watch =
+          watched?.status === "idle"
+            ? ` ${session.name} is idle now.`
+            : ` You will get one notice when ${session.name} next goes idle or exits.`;
+      } catch {
+        watch = ` Could not ask to be told when ${session.name} goes idle.`;
+      }
+    }
+    const said =
+      status === "delivered" && reply?.waiting === true
+        ? `Delivered to ${session.name} (${session.sessionId}), which has had no prompt yet: its agent reads the message when its user next sends one. A reply, if it sends one, reaches you as a notice: you do not need to wait or look for it.`
+        : status === "delivered"
+          ? `Delivered to ${session.name} (${session.sessionId}). A reply, if it sends one, reaches you as a notice: you do not need to wait or look for it.`
+          : status === "held"
+            ? `Held for ${session.name}'s user to accept or refuse; you will get a notice with the outcome (at most ${HOLD_EXPIRY_MS / 60_000} minutes).`
+            : `Refused by ${session.name}${reply?.reason ? `: ${reply.reason}` : "."}`;
+    return this.result(status === "delivered" || status === "held", `${said}${watch}`, {
+      to: session.sessionId,
+      name: session.name,
+      status,
+      id,
+      ...(reply?.waiting === true ? { waiting: true } : {}),
+    });
+  }
+  result(ok, text, details) {
+    return { ok, text, details };
+  }
+  published = "";
+  /** Write this session's registry entry when it changed. */
+  /** One registry write at a time, in order, so a busy flag written later is never overwritten by an earlier one. */
+  publish() {
+    const run = this.writing.then(() => this.write());
+    this.writing = run.catch(() => {});
+    return run;
+  }
+  async write() {
+    const me = this.me;
+    if (!me || this.stopping) return;
+    const entry = {
+      sessionId: me.sessionId,
+      name: me.name,
+      cwd: me.cwd,
+      pid: process.pid,
+      socket: me.socket,
+      busy: this.busyNow,
+      ...(me.project ? { project: me.project } : {}),
+      ...(me.task ? { task: me.task } : {}),
+      ...(me.owns?.length ? { owns: me.owns } : {}),
+      startedAt: this.startedAt,
+    };
+    const text = JSON.stringify(entry);
+    if (text === this.published) return;
+    await this.registry.write(entry);
+    this.published = text;
+  }
+  startedAt = new Date().toISOString();
+  /** One request from another session. */
+  async handle(body) {
+    const from = body?.from;
+    if (!this.me) return { status: "refused", reason: "Messaging is off in this session." };
+    if (!from || typeof from.sessionId !== "string" || typeof from.socket !== "string")
+      return { status: "refused", reason: "The request names no sender." };
+    if (body.type === "message") return this.receive(body, from);
+    if (body.type === "watch") {
+      if (!this.busyNow) return { status: "idle" };
+      this.watchers.set(from.sessionId, { sender: from, until: Date.now() + WATCH_EXPIRY_MS });
+      return { status: "watching" };
+    }
+    if (body.type === "outcome") {
+      const outcome =
+        body.status === "accepted"
+          ? "was accepted by its user and delivered"
+          : body.status === "refused"
+            ? "was refused by its user"
+            : "was not answered in time and was dropped";
+      this.host.deliver(
+        `<message-status to="${attribute(from.name)}" session="${attribute(from.sessionId)}">Your message ${outcome}.</message-status>`,
+        {
+          kind: "outcome",
+          from: from.sessionId,
+          name: from.name,
+          status: body.status,
+          id: body.id,
+        },
+      );
+      return { status: "ok" };
+    }
+    if (body.type === "idle" || body.type === "exited") {
+      this.host.deliver(
+        `<session-status name="${attribute(from.name)}" session="${attribute(from.sessionId)}">${body.type === "idle" ? "The session is now idle." : "The session has ended."}</session-status>`,
+        { kind: body.type, from: from.sessionId, name: from.name },
+      );
+      return { status: "ok" };
+    }
+    return { status: "refused", reason: `Unknown request type ${String(body.type)}.` };
+  }
+  async receive(body, from) {
+    const text = typeof body.text === "string" ? body.text : "";
+    if (text.trim() === "") return { status: "refused", reason: "The message is empty." };
+    if (text.length > MAX_MESSAGE_CHARS) return { status: "refused", reason: "The message is too large." };
+    const now = Date.now();
+    const recent = (this.received.get(from.sessionId) ?? []).filter((at) => now - at < 60_000);
+    if (recent.length >= PER_SENDER_PER_MINUTE)
+      return { status: "refused", reason: `More than ${PER_SENDER_PER_MINUTE} messages a minute from one session.` };
+    this.accepted = this.accepted.filter((at) => now - at < 60_000);
+    if (this.accepted.length >= ACCEPTED_PER_MINUTE)
+      return { status: "refused", reason: "This session is receiving too many messages; try again later." };
+    this.received.set(from.sessionId, [...recent, now]);
+    const policy = this.host.policy();
+    const decision =
+      policy === "refuse"
+        ? "refuse"
+        : policy === "accept"
+          ? "accept"
+          : policy === "hold"
+            ? "hold"
+            : from.project && from.project === this.me?.project
+              ? "accept"
+              : "hold";
+    if (decision === "refuse") return { status: "refused", reason: "This session does not accept messages." };
+    if (decision === "hold" && !this.host.canAsk())
+      return {
+        status: "refused",
+        reason: "This session holds messages from outside its project, and has no UI to ask its user.",
+      };
+    const message = {
+      id: String(body.id ?? randomUUID()),
+      from,
+      text,
+      ...(typeof body.summary === "string" ? { summary: body.summary } : {}),
+      at: now,
+    };
+    if (decision === "accept") {
+      this.accepted.push(now);
+      this.deliverMessage(message);
+      return { status: "delivered", ...(this.host.canWake?.() === false ? { waiting: true } : {}) };
+    }
+    if (this.held.length >= MAX_HELD) {
+      // The oldest waiting message goes, never the one the user is looking at in the dialog.
+      const [dropped] = this.held.splice(this.asking ? 1 : 0, 1);
+      if (dropped) void this.outcome(dropped, "expired");
+    }
+    this.held.push(message);
+    void this.askNext();
+    return { status: "held" };
+  }
+  /** Put held messages to the user one at a time; each dialog expires, and the sender learns the outcome. */
+  async askNext() {
+    if (this.asking) return;
+    this.asking = true;
+    try {
+      while (this.held.length > 0) {
+        const message = this.held[0];
+        const left = this.holdExpiryMs - (Date.now() - message.at);
+        let answer = false;
+        if (left > 0) {
+          const preview = message.text.length > 600 ? `${message.text.slice(0, 600)}...` : message.text;
+          answer = await this.host.confirm(
+            `Message from ${message.from.name}`,
+            `${message.from.name} (${message.from.cwd}${message.from.project ? `, project ${message.from.project}` : ""}) sent:\n\n${preview}\n\nDeliver it to the agent in this session?`,
+            left,
+          );
+        }
+        if (this.held[0] !== message) continue;
+        this.held.shift();
+        if (answer === true) {
+          this.accepted.push(Date.now());
+          this.deliverMessage(message);
+        }
+        const expired =
+          !answer && Date.now() - message.at >= this.holdExpiryMs - Math.min(1_000, this.holdExpiryMs / 10);
+        await this.outcome(message, answer ? "accepted" : expired ? "expired" : "refused");
+      }
+    } finally {
+      this.asking = false;
+    }
+  }
+  deliverMessage(message) {
+    const from = message.from;
+    // The tag marks it as another agent's message; the messaging skill says what to do with it (Task 002 D-008).
+    const attributes = [
+      `from="${attribute(from.name)}"`,
+      `session="${attribute(from.sessionId)}"`,
+      `folder="${attribute(from.cwd)}"`,
+      ...(from.task ? [`task="${attribute(from.task)}"`] : []),
+    ].join(" ");
+    this.host.deliver(`<message ${attributes}>\n${escapeBody(message.text)}\n</message>`, {
+      kind: "message",
+      from: from.sessionId,
+      name: from.name,
+      id: message.id,
+      ...(message.summary ? { summary: message.summary } : {}),
+    });
+  }
+  async outcome(message, status) {
+    if (!this.me) return;
+    try {
+      await request(message.from.socket, { type: "outcome", id: message.id, status, from: this.me });
+    } catch {
+      // The sender is gone; nothing to tell.
+    }
+  }
+  async notifyWatchers(type) {
+    const me = this.me;
+    if (!me) return;
+    const now = Date.now();
+    const watchers = [...this.watchers.values()];
+    this.watchers.clear();
+    for (const { sender, until } of watchers) {
+      if (until < now) continue;
+      try {
+        await request(sender.socket, { type, from: me });
+      } catch {
+        // The watcher is gone.
+      }
+    }
+  }
+}

package/pi-extension/dist/messaging/registry.js

@@ -0,0 +1,57 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const fileName = (sessionId) => `${sessionId.replace(/[^A-Za-z0-9._-]/g, "_")}.json`;
+export function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === "EPERM";
+  }
+}
+export class LiveRegistry {
+  folder;
+  constructor(home) {
+    this.folder = join(home, "sessions");
+  }
+  async write(entry) {
+    await mkdir(this.folder, { recursive: true, mode: 0o700 });
+    const path = join(this.folder, fileName(entry.sessionId));
+    // One temporary file per write, so two writes in flight never rename each other's file.
+    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(entry, null, 2)}\n`, { mode: 0o600 });
+    await rename(temporary, path);
+  }
+  async remove(sessionId) {
+    await rm(join(this.folder, fileName(sessionId)), { force: true });
+  }
+  /** Every live session, oldest first; stale entries and their sockets are removed on the way. */
+  async list() {
+    let names;
+    try {
+      names = await readdir(this.folder);
+    } catch {
+      return [];
+    }
+    const sessions = [];
+    for (const name of names.filter((each) => each.endsWith(".json"))) {
+      const path = join(this.folder, name);
+      let entry;
+      try {
+        entry = JSON.parse(await readFile(path, "utf8"));
+      } catch {
+        continue;
+      }
+      if (typeof entry?.pid !== "number" || typeof entry.sessionId !== "string" || typeof entry.socket !== "string")
+        continue;
+      if (!alive(entry.pid)) {
+        await rm(path, { force: true });
+        await rm(entry.socket, { force: true });
+        continue;
+      }
+      sessions.push(entry);
+    }
+    return sessions.sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+  }
+}

package/pi-extension/dist/messaging/render.js

@@ -0,0 +1,90 @@
+import { Text } from "@earendil-works/pi-tui";
+import { firstLine, foldRow, paint } from "../host/rows.js";
+/** Transcript rows for messaging (Task 002 D-008): what was sent to whom, what arrived from whom, and outcomes. */
+const statusColor = (status) =>
+  status === "delivered"
+    ? "success"
+    : status === "held"
+      ? "warning"
+      : status === "refused" || status === "failed"
+        ? "error"
+        : "muted";
+/** What the row adds under its head: the whole text when expanded, otherwise the lines after the first, if any. */
+function bodyAfterHead(text, expanded) {
+  if (expanded) return text.length > 100 || text.includes("\n") ? [text] : [];
+  const lines = text.split("\n");
+  const first = lines.findIndex((line) => line.trim());
+  return lines
+    .slice(first + 1)
+    .join("\n")
+    .trim()
+    ? [
+        lines
+          .slice(first + 1)
+          .join("\n")
+          .trim(),
+      ]
+    : [];
+}
+/** A session's name for a row: the name the result gave, or the one this session has seen, or a short ID. */
+function shownName(id, context, nameOf) {
+  const named = context?.state?.name ?? nameOf?.(id);
+  if (named) return named;
+  return id.length > 12 ? `${id.slice(0, 8)}…` : id;
+}
+export function renderSendCall(args, theme, context, nameOf) {
+  const to = shownName(String(args?.to ?? ""), context, nameOf);
+  const message = String(args?.message ?? "");
+  const head = `${paint(theme, "toolTitle", "Message")} ${paint(theme, "accent", `→ ${to}`)}${message ? `: ${paint(theme, "muted", firstLine(message))}` : ""}`;
+  return foldRow(head, bodyAfterHead(message, context?.expanded === true), context?.expanded === true, theme);
+}
+export function renderSendResult(result, options, theme, context) {
+  const details = result?.details ?? {};
+  // The call line shows the address as a name once the result names the session.
+  if (context?.state && details.name && context.state.name !== details.name) {
+    context.state.name = details.name;
+    // After this render: invalidating inside it makes Pi rebuild the row and then add this result again.
+    queueMicrotask(() => context.invalidate?.());
+  }
+  const status = String(details.status ?? (result?.isError ? "failed" : "sent"));
+  const name = details.name ?? details.to ?? "";
+  const text = (result?.content ?? []).map((part) => part?.text ?? "").join("\n");
+  const said =
+    status === "delivered"
+      ? `Delivered${name ? ` to ${name}` : ""}`
+      : status === "held"
+        ? `Held for ${name || "the other session"}'s user to accept`
+        : firstLine(text, 140) || status;
+  const extra = text.split("\n\n").slice(1).join("\n\n");
+  return foldRow(paint(theme, statusColor(status), said), extra ? [extra] : [], options?.expanded === true, theme);
+}
+export function renderListResult(result, options, theme) {
+  const sessions = result?.details?.sessions ?? [];
+  const text = (result?.content ?? []).map((part) => part?.text ?? "").join("\n");
+  const head = paint(theme, "muted", `${sessions.length} other ${sessions.length === 1 ? "session" : "sessions"}`);
+  return foldRow(head, text.split("\n").slice(1), options?.expanded === true, theme);
+}
+/** A received message, a held message's outcome, or a watched session's status, delivered as a Freeflow message. */
+export function renderMessage(message, options, theme) {
+  const details = message?.details ?? {};
+  const content = typeof message?.content === "string" ? message.content : "";
+  const inner = content.replace(/^<[^>]*>\n?/, "").replace(/\n?<\/[a-z-]+>\s*$/, "");
+  const label = paint(theme, "customMessageLabel", "Message");
+  if (details.kind === "outcome") {
+    const outcome =
+      details.status === "accepted"
+        ? "accepted and delivered"
+        : details.status === "refused"
+          ? "refused"
+          : "not answered in time";
+    return new Text(`${label} ${paint(theme, "muted", `to ${details.name ?? details.from}: ${outcome}`)}`, 0, 0);
+  }
+  if (details.kind === "idle" || details.kind === "exited")
+    return new Text(
+      `${paint(theme, "customMessageLabel", "Session")} ${paint(theme, "muted", `${details.name ?? details.from} ${details.kind === "idle" ? "is now idle" : "has ended"}`)}`,
+      0,
+      0,
+    );
+  const head = `${label} ${paint(theme, "accent", `← ${details.name ?? details.from ?? "another session"}`)}: ${paint(theme, "muted", firstLine(inner))}`;
+  return foldRow(head, bodyAfterHead(inner, options?.expanded === true), options?.expanded === true, theme);
+}