@herbertgao/pi-extensions 2026.8.2 → 2026.8.4

package/node_modules/pi-footer/src/widgets/options.ts

@@ -0,0 +1,122 @@
+import { normalizeColor } from "../colors.js";
+import type { WidgetOptions } from "../types.js";
+import type { WidgetProperty, WidgetPropertyDefault, WidgetSpec } from "./types.js";
+
+const SYSTEM_BASE_OPTION_DEFAULTS = {
+  raw: false,
+  hideWhenEmpty: false,
+  hideWhenZero: false,
+  text: "-",
+  icon: "",
+} as const;
+
+// The options-relevant slice of a spec, derived from WidgetSpec (excludes render so concrete
+// widget specs stay assignable — render's generic params make the full spec invariant).
+type WidgetOptionsSpec = Pick<
+  WidgetSpec,
+  "baseOptions" | "baseOptionDefaults" | "properties" | "defaultStyle" | "createOptionDefaults"
+>;
+
+export function defaultOptionsFromSpec(spec: WidgetOptionsSpec): WidgetOptions {
+  const base: WidgetOptions = {};
+
+  for (const option of spec.baseOptions) {
+    const optionId: string = option;
+    base[optionId] = SYSTEM_BASE_OPTION_DEFAULTS[option];
+  }
+  Object.assign(base, spec.baseOptionDefaults ?? {});
+
+  for (const property of spec.properties) {
+    base[property.id] = property.default;
+  }
+
+  const dynamicDefaults = spec.createOptionDefaults?.();
+  if (dynamicDefaults) Object.assign(base, dynamicDefaults);
+
+  if (spec.defaultStyle.fg !== undefined) base.fg = spec.defaultStyle.fg;
+  if (spec.defaultStyle.bg !== undefined) base.bg = spec.defaultStyle.bg;
+  if (spec.defaultStyle.bold !== undefined) base.bold = spec.defaultStyle.bold;
+
+  return base;
+}
+
+export function sanitizeOptionsFromSpec(
+  spec: WidgetOptionsSpec,
+  input: Record<string, unknown>,
+): WidgetOptions {
+  const defaults = defaultOptionsFromSpec(spec);
+  const merged: Record<string, unknown> = { ...defaults, ...input };
+  const next: WidgetOptions = {};
+
+  for (const option of spec.baseOptions) {
+    if (!(option in defaults)) continue;
+    const optionId: string = option;
+    next[optionId] = sanitizeMetadataValue(merged[optionId], defaults[optionId]);
+  }
+
+  const fg = normalizeColor(merged.fg);
+  if (fg) next.fg = fg;
+  const bg = normalizeColor(merged.bg);
+  if (bg) next.bg = bg;
+  next.bold = typeof merged.bold === "boolean" ? merged.bold : Boolean(defaults.bold);
+
+  for (const property of spec.properties) {
+    next[property.id] = sanitizeWidgetProperty(property, merged[property.id]);
+  }
+
+  return next;
+}
+
+function sanitizeWidgetProperty(
+  property: WidgetProperty,
+  value: unknown,
+): string | number | boolean {
+  switch (property.kind) {
+    case "boolean":
+      return typeof value === "boolean" ? value : property.default;
+    case "number":
+      return sanitizeMetadataNumber(
+        value,
+        property.default,
+        property.options?.min,
+        property.options?.max,
+      );
+    case "text":
+      if (
+        property.id === "warningFg" ||
+        property.id === "warningBg" ||
+        property.id === "dangerFg" ||
+        property.id === "dangerBg"
+      )
+        return normalizeColor(value) ?? property.default;
+      return typeof value === "string" ? value : property.default;
+    case "choice": {
+      const choices = property.options?.choices ?? [];
+      return typeof value === "string" && choices.some((choice) => choice.id === value)
+        ? value
+        : property.default;
+    }
+  }
+}
+
+function sanitizeMetadataValue(
+  value: unknown,
+  defaultValue: WidgetOptions[keyof WidgetOptions],
+): WidgetOptions[keyof WidgetOptions] {
+  if (typeof defaultValue === "boolean") return typeof value === "boolean" ? value : defaultValue;
+  if (typeof defaultValue === "number")
+    return typeof value === "number" && Number.isInteger(value) ? value : defaultValue;
+  if (typeof defaultValue === "string") return typeof value === "string" ? value : defaultValue;
+  return defaultValue;
+}
+
+function sanitizeMetadataNumber(
+  value: unknown,
+  defaultValue: WidgetPropertyDefault,
+  min = Number.NEGATIVE_INFINITY,
+  max = Number.POSITIVE_INFINITY,
+): number {
+  const numberValue = typeof value === "number" && Number.isInteger(value) ? value : defaultValue;
+  const safeNumber = typeof numberValue === "number" ? numberValue : 0;
+  return Math.min(max, Math.max(min, safeNumber));
+}

package/node_modules/pi-footer/src/widgets/project/runtime.ts

@@ -0,0 +1,361 @@
+import { execFile } from "node:child_process";
+import { readdir } from "node:fs/promises";
+
+import type { ColorName } from "../../colors.js";
+import { CACHE_NAMESPACES, asyncCache } from "../../cache.js";
+import type { WidgetIconSet } from "../types.js";
+import { defineWidget } from "../types.js";
+
+const VERSION_TIMEOUT_MS = 1_000;
+const RUNTIME_CACHE_TTL_MS = 10_000;
+
+interface VersionCommand {
+  command: string;
+  args: readonly string[];
+  parse: (output: string) => string | undefined;
+}
+
+interface RuntimeDefinition<TName extends string = string> {
+  name: TName;
+  files: readonly string[];
+  matchesEntry?: (entry: CwdEntry) => boolean;
+  versionCommands: readonly VersionCommand[];
+  icons: WidgetIconSet;
+  color: ColorName;
+}
+
+interface CwdEntry {
+  name: string;
+  isFile: boolean;
+}
+
+const RUNTIME_DEFINITIONS = [
+  {
+    name: "bun",
+    files: ["bun.lock", "bun.lockb"],
+    versionCommands: [
+      {
+        command: "bun",
+        args: ["--version"],
+        parse: (output) => /\bv?([0-9][^\s]*)/i.exec(output)?.[1],
+      },
+    ],
+    icons: { emoji: "🥟", nerd: "", text: "" },
+    color: "pi:warning",
+  },
+  {
+    name: "deno",
+    files: ["deno.json", "deno.jsonc", "deno.lock"],
+    versionCommands: [
+      {
+        command: "deno",
+        args: ["--version"],
+        parse: (output) => /deno\s+([0-9][^\s]*)/i.exec(output)?.[1],
+      },
+    ],
+    icons: { emoji: "🦕", nerd: "", text: "" },
+    color: "pi:syntaxType",
+  },
+  {
+    name: "lua",
+    files: ["stylua.toml", ".stylua.toml", ".luarc.json", ".luarc.jsonc", "init.lua"],
+    matchesEntry: (entry) => entry.name === "lua" || (entry.isFile && entry.name.endsWith(".lua")),
+    versionCommands: [
+      { command: "lua", args: ["-v"], parse: (output) => /Lua\s+([0-9][^\s]*)/i.exec(output)?.[1] },
+      {
+        command: "luajit",
+        args: ["-v"],
+        parse: (output) => /LuaJIT\s+([0-9][^\s]*)/i.exec(output)?.[1],
+      },
+    ],
+    icons: { emoji: "🌙", nerd: "", text: "" },
+    color: "pi:accent",
+  },
+  {
+    name: "node",
+    files: ["package.json", ".nvmrc", ".node-version"],
+    versionCommands: [
+      {
+        command: "node",
+        args: ["--version"],
+        parse: (output) => /\bv?([0-9][^\s]*)/i.exec(output)?.[1],
+      },
+    ],
+    icons: { emoji: "⬢", nerd: "", text: "" },
+    color: "pi:success",
+  },
+  {
+    name: "python",
+    files: [
+      "pyproject.toml",
+      "requirements.txt",
+      "setup.py",
+      "setup.cfg",
+      "Pipfile",
+      ".python-version",
+    ],
+    versionCommands: [
+      {
+        command: "python3",
+        args: ["--version"],
+        parse: (output) => /Python\s+([0-9][^\s]*)/i.exec(output)?.[1],
+      },
+      {
+        command: "python",
+        args: ["--version"],
+        parse: (output) => /Python\s+([0-9][^\s]*)/i.exec(output)?.[1],
+      },
+    ],
+    icons: { emoji: "🐍", nerd: "", text: "" },
+    color: "pi:warning",
+  },
+  {
+    name: "go",
+    files: ["go.mod"],
+    versionCommands: [
+      {
+        command: "go",
+        args: ["version"],
+        parse: (output) => /go version go([0-9][^\s]*)/i.exec(output)?.[1],
+      },
+    ],
+    icons: { emoji: "🐹", nerd: "", text: "" },
+    color: "pi:syntaxType",
+  },
+  {
+    name: "rust",
+    files: ["Cargo.toml"],
+    versionCommands: [
+      {
+        command: "rustc",
+        args: ["--version"],
+        parse: (output) => /rustc\s+([0-9][^\s]*)/i.exec(output)?.[1],
+      },
+    ],
+    icons: { emoji: "🦀", nerd: "", text: "" },
+    color: "pi:error",
+  },
+  {
+    name: "java",
+    files: ["pom.xml", "build.gradle", "build.gradle.kts"],
+    versionCommands: [
+      {
+        command: "java",
+        args: ["-version"],
+        parse: (output) => /(?:openjdk|java)\s+version\s+"?([0-9][^"\s]*)/i.exec(output)?.[1],
+      },
+    ],
+    icons: { emoji: "☕", nerd: "", text: "" },
+    color: "pi:warning",
+  },
+  {
+    name: "ruby",
+    files: ["Gemfile", ".ruby-version"],
+    versionCommands: [
+      {
+        command: "ruby",
+        args: ["--version"],
+        parse: (output) => /ruby\s+([0-9][^\s]*)/i.exec(output)?.[1],
+      },
+    ],
+    icons: { emoji: "💎", nerd: "", text: "" },
+    color: "pi:error",
+  },
+  {
+    name: "php",
+    files: ["composer.json"],
+    versionCommands: [
+      {
+        command: "php",
+        args: ["--version"],
+        parse: (output) => /PHP\s+([0-9][^\s]*)/i.exec(output)?.[1],
+      },
+    ],
+    icons: { emoji: "🐘", nerd: "", text: "" },
+    color: "pi:accent",
+  },
+] as const satisfies readonly RuntimeDefinition[];
+
+export type RuntimeName = (typeof RUNTIME_DEFINITIONS)[number]["name"];
+
+interface RuntimeInfo {
+  name: RuntimeName;
+  version?: string;
+  icons: WidgetIconSet;
+  color: ColorName;
+}
+
+interface RuntimeDetection {
+  cwd: string;
+  displayVersion: boolean;
+}
+
+export const RuntimeWidget = defineWidget({
+  type: "runtime",
+  label: "Runtime",
+  category: "Project",
+  description: "Current project runtime (e.g. Bun, Python, Go, Rust)",
+  dependencies: ["cwd"],
+  baseOptions: ["raw", "hideWhenEmpty", "icon", "text"],
+  baseOptionDefaults: { hideWhenEmpty: true },
+  properties: [
+    {
+      id: "style",
+      label: "Style",
+      kind: "choice",
+      description: "Display style",
+      default: "compact",
+      options: {
+        choices: [
+          { id: "default", label: "Default", list: "default" },
+          { id: "compact", label: "Compact", list: "compact" },
+        ],
+        showInWidgets: true,
+        showInColors: false,
+        listProperty: "style",
+      },
+    },
+    {
+      id: "displayVersion",
+      label: "Display version",
+      kind: "boolean",
+      description: "Show runtime version",
+      default: true,
+      options: {
+        label: "with-version",
+        showInWidgets: true,
+        showInColors: true,
+        listProperty: "",
+      },
+    },
+  ],
+  icons: { emoji: "⚙️", nerd: "", text: "runtime" },
+  defaultStyle: { fg: "default", bg: "default", bold: false },
+  render({ ctx, options, renderWidget }) {
+    const cwd = ctx.cwd;
+    if (cwd.length === 0) return renderWidget("");
+
+    const info = asyncCache.get(
+      CACHE_NAMESPACES.runtime,
+      `${cwd}:${options.displayVersion ? "version" : "no-version"}`,
+      RUNTIME_CACHE_TTL_MS,
+      { cwd, displayVersion: options.displayVersion },
+      detectRuntime,
+      ctx.requestRender,
+    );
+    if (!info) return renderWidget("", { icons: { emoji: "", nerd: "", text: "" } });
+
+    return renderWidget(renderRuntimeValue(info, options.displayVersion, options.style), {
+      icons: info.icons,
+      fg: options.fg && options.fg !== "default" ? options.fg : info.color,
+    });
+  },
+});
+
+function renderRuntimeValue(
+  info: RuntimeInfo,
+  displayVersion: boolean,
+  style: "default" | "compact",
+) {
+  if (!displayVersion || !info.version) return info.name;
+  if (style === "compact") return compactRuntimeVersion(info.name, info.version);
+  return `${info.name} ${info.version}`;
+}
+
+function prefixRuntimeVersion(version: string) {
+  const trimmed = version.trim();
+  if (!trimmed) return trimmed;
+  return trimmed.toLowerCase().startsWith("v") ? trimmed : `v${trimmed}`;
+}
+
+function compactRuntimeVersion(name: RuntimeName, version: string) {
+  const prefixed = prefixRuntimeVersion(version);
+  const match = /^v([0-9]+)(?:\.([0-9]+))?/i.exec(prefixed);
+  if (!match) return prefixed;
+
+  const major = match[1] ?? "";
+  const minor = match[2];
+  if ((name === "python" || name === "go" || name === "bun") && minor !== undefined)
+    return `v${major}.${minor}`;
+  return `v${major}`;
+}
+
+async function detectRuntime({
+  cwd,
+  displayVersion,
+}: RuntimeDetection): Promise<RuntimeInfo | null> {
+  const entries = await readCwdEntries(cwd);
+  if (!entries) return null;
+
+  for (const definition of RUNTIME_DEFINITIONS) {
+    if (!matchesRuntime(definition, entries)) continue;
+
+    const version = displayVersion ? await detectVersion(definition) : undefined;
+    return version
+      ? {
+          name: definition.name,
+          version,
+          icons: definition.icons,
+          color: definition.color,
+        }
+      : {
+          name: definition.name,
+          icons: definition.icons,
+          color: definition.color,
+        };
+  }
+
+  return null;
+}
+
+async function readCwdEntries(cwd: string) {
+  try {
+    const entries = await readdir(cwd, { withFileTypes: true });
+    return entries.map((entry) => ({ name: entry.name, isFile: entry.isFile() }));
+  } catch {
+    return undefined;
+  }
+}
+
+function matchesRuntime(definition: RuntimeDefinition, entries: readonly CwdEntry[]) {
+  if (hasAnyFile(entries, definition.files)) return true;
+  return definition.matchesEntry
+    ? entries.some((entry) => definition.matchesEntry?.(entry) === true)
+    : false;
+}
+
+function hasAnyFile(entries: readonly CwdEntry[], files: readonly string[]) {
+  const fileNames = new Set(entries.filter((entry) => entry.isFile).map((entry) => entry.name));
+  return files.some((file) => fileNames.has(file));
+}
+
+async function detectVersion(definition: RuntimeDefinition) {
+  for (const command of definition.versionCommands) {
+    const version = await runVersion(command);
+    if (version) return version;
+  }
+  return undefined;
+}
+
+async function runVersion(versionCommand: VersionCommand) {
+  return new Promise<string | undefined>((resolve) => {
+    execFile(
+      versionCommand.command,
+      [...versionCommand.args],
+      { encoding: "utf8", timeout: VERSION_TIMEOUT_MS, windowsHide: true },
+      (error, stdout, stderr) => {
+        const output = `${stringOutput(stdout)}\n${stringOutput(stderr)}`;
+        if (error && output.trim().length === 0) {
+          resolve(undefined);
+          return;
+        }
+        const parsed = versionCommand.parse(output);
+        resolve(parsed ? prefixRuntimeVersion(parsed) : undefined);
+      },
+    );
+  });
+}
+
+function stringOutput(value: string | Buffer) {
+  return typeof value === "string" ? value : value.toString("utf8");
+}

package/node_modules/pi-footer/src/widgets/registry.ts

@@ -0,0 +1,223 @@
+import type { WidgetEntry, WidgetOptions } from "../types.js";
+import { ActiveToolsWidget } from "./core/active-tools.js";
+import { ContextWindowWidget } from "./core/context-window.js";
+import { CwdBasenameWidget } from "./core/cwd-basename.js";
+import { CwdWidget } from "./core/cwd.js";
+import { EventValueWidget } from "./core/event.js";
+import { ExtensionStatusWidget } from "./core/external-status.js";
+import { ModelProviderWidget } from "./core/model-provider.js";
+import { ModelWidget } from "./core/model.js";
+import { ProviderWidget } from "./core/provider.js";
+import { SessionNameWidget } from "./core/session-name.js";
+import { TextVerbosityWidget } from "./core/text-verbosity.js";
+import { ThinkingLevelWidget } from "./core/thinking-level.js";
+import { GitAheadBehindWidget } from "./git/ahead-behind.js";
+import { GitBranchWidget } from "./git/branch.js";
+import { GitCleanStatusWidget } from "./git/clean.js";
+import { GitDeletionsWidget } from "./git/deletions.js";
+import { GitDiffWidget } from "./git/diff.js";
+import { GitInsertionsWidget } from "./git/insertions.js";
+import { GitRemoteWidget } from "./git/remote.js";
+import { GitRootDirWidget } from "./git/root.js";
+import { GitShaWidget } from "./git/sha.js";
+import { GitStagedWidget } from "./git/staged.js";
+import { GitStatusWidget } from "./git/status.js";
+import { GitUnstagedWidget } from "./git/unstaged.js";
+import { GitUntrackedWidget } from "./git/untracked.js";
+import { WidgetInstance } from "./instance.js";
+import { CustomTextWidget } from "./layout/custom-text.js";
+import { FlexSeparatorWidget } from "./layout/flex-separator.js";
+import { SeparatorWidget } from "./layout/separator.js";
+import { SpacerWidget } from "./layout/spacer.js";
+import { sanitizeOptionsFromSpec } from "./options.js";
+import { RuntimeWidget } from "./project/runtime.js";
+import { AssistantMessagesWidget } from "./session/assistant-messages.js";
+import { CompactionsWidget } from "./session/compactions.js";
+import { ElapsedWidget } from "./session/elapsed.js";
+import { LastActivityWidget } from "./session/last-activity.js";
+import { MessagesWidget } from "./session/messages.js";
+import { SessionIdWidget } from "./session/session-id.js";
+import { SessionStartWidget } from "./session/session-start.js";
+import { ToolResultsWidget } from "./session/tool-results.js";
+import { TotalMessagesWidget } from "./session/total-messages.js";
+import { TotalTimeWidget } from "./session/total-time.js";
+import { UserMessagesWidget } from "./session/user-messages.js";
+import { CacheHitRateWidget } from "./tokens/cache-hit-rate.js";
+import { CacheReadWidget } from "./tokens/cache-read.js";
+import { CacheWriteWidget } from "./tokens/cache-write.js";
+import { ContextBarWidget } from "./tokens/context-bar.js";
+import { ContextLengthWidget } from "./tokens/context-length.js";
+import { ContextRemainingWidget } from "./tokens/context-remaining.js";
+import { ContextWidget } from "./tokens/context.js";
+import { CostWidget } from "./tokens/cost.js";
+import { InputSpeedWidget } from "./tokens/input-speed.js";
+import { InputTokensWidget } from "./tokens/input-tokens.js";
+import { OutputSpeedWidget } from "./tokens/output-speed.js";
+import { OutputTokensWidget } from "./tokens/output-tokens.js";
+import { TokensWidget } from "./tokens/tokens.js";
+import { TotalSpeedWidget } from "./tokens/total-speed.js";
+import { TotalTokensWidget } from "./tokens/total-tokens.js";
+import type { Widget } from "./types.js";
+
+const WIDGETS = [
+  ModelWidget,
+  ProviderWidget,
+  ModelProviderWidget,
+  ThinkingLevelWidget,
+  TextVerbosityWidget,
+  ContextWindowWidget,
+  ActiveToolsWidget,
+  SessionNameWidget,
+  CwdWidget,
+  CwdBasenameWidget,
+  EventValueWidget,
+  ExtensionStatusWidget,
+  CustomTextWidget,
+  SeparatorWidget,
+  SpacerWidget,
+  FlexSeparatorWidget,
+  RuntimeWidget,
+  AssistantMessagesWidget,
+  CompactionsWidget,
+  ElapsedWidget,
+  LastActivityWidget,
+  MessagesWidget,
+  SessionIdWidget,
+  SessionStartWidget,
+  ToolResultsWidget,
+  TotalMessagesWidget,
+  TotalTimeWidget,
+  UserMessagesWidget,
+  GitAheadBehindWidget,
+  GitBranchWidget,
+  GitCleanStatusWidget,
+  GitDeletionsWidget,
+  GitDiffWidget,
+  GitInsertionsWidget,
+  GitRemoteWidget,
+  GitRootDirWidget,
+  GitShaWidget,
+  GitStagedWidget,
+  GitStatusWidget,
+  GitUnstagedWidget,
+  GitUntrackedWidget,
+  ContextBarWidget,
+  ContextLengthWidget,
+  ContextWidget,
+  ContextRemainingWidget,
+  CostWidget,
+  CacheReadWidget,
+  CacheWriteWidget,
+  CacheHitRateWidget,
+  TokensWidget,
+  InputTokensWidget,
+  OutputTokensWidget,
+  TotalTokensWidget,
+  InputSpeedWidget,
+  OutputSpeedWidget,
+  TotalSpeedWidget,
+] as const;
+
+export type WidgetSpecUnion = (typeof WIDGETS)[number];
+export type WidgetType = WidgetSpecUnion["type"];
+export type WidgetCategory = WidgetSpecUnion["category"];
+
+export interface WidgetDefinition {
+  readonly type: WidgetType;
+  readonly label: string;
+  readonly category: WidgetCategory;
+  readonly description: string;
+}
+
+interface WidgetRegistry {
+  readonly specs: readonly WidgetSpecUnion[];
+  readonly definitions: readonly WidgetDefinition[];
+  readonly types: readonly WidgetType[];
+  readonly typeSet: ReadonlySet<WidgetType>;
+
+  spec(type: WidgetType): WidgetSpecUnion;
+  maybeSpec(type: string): WidgetSpecUnion | undefined;
+  createEntry(type: WidgetType, options?: Record<string, unknown>): WidgetEntry;
+  cloneEntry(entry: WidgetEntry): WidgetEntry;
+  normalizeOptions(type: WidgetType, input: Record<string, unknown>): WidgetOptions;
+  createWidget(type: WidgetType, options?: Record<string, unknown>): Widget;
+  cloneWidget(widget: Widget): Widget;
+  hydrateWidget(entry: WidgetEntry): Widget;
+}
+
+function createWidgetRegistry(widgets: readonly WidgetSpecUnion[]): WidgetRegistry {
+  const specs = [...widgets];
+  const specsByType = new Map<WidgetType, WidgetSpecUnion>(
+    specs.map((spec) => [spec.type as WidgetType, spec]),
+  );
+  const definitions = specs.map(definitionFromWidgetSpec);
+  const types = definitions.map((definition) => definition.type);
+  const typeSet = new Set<WidgetType>(types);
+
+  const specFor = (type: WidgetType): WidgetSpecUnion => {
+    const spec = specsByType.get(type);
+    if (!spec) throw new Error(`Unsupported widget type: ${type}`);
+    return spec;
+  };
+
+  const buildEntry = (
+    type: WidgetType,
+    options: Record<string, unknown> = {},
+    enabled = true,
+  ): WidgetEntry => ({
+    id: `${type}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+    type,
+    enabled,
+    options: sanitizeOptionsFromSpec(specFor(type), options),
+  });
+
+  return {
+    specs,
+    definitions,
+    types,
+    typeSet,
+    spec(type) {
+      return specFor(type);
+    },
+    maybeSpec(type) {
+      return specsByType.get(type as WidgetType);
+    },
+    createEntry(type, options = {}) {
+      return buildEntry(type, options);
+    },
+    normalizeOptions(type, input) {
+      return sanitizeOptionsFromSpec(specFor(type), input);
+    },
+    cloneEntry(entry) {
+      return buildEntry(entry.type, entry.options, entry.enabled);
+    },
+    createWidget(type, options = {}) {
+      return new WidgetInstance(specFor(type), buildEntry(type, options));
+    },
+    cloneWidget(widget) {
+      return new WidgetInstance(
+        specFor(widget.type),
+        buildEntry(widget.type, widget.options, widget.enabled),
+      );
+    },
+    hydrateWidget(entry) {
+      return new WidgetInstance(specFor(entry.type), {
+        id: entry.id,
+        type: entry.type,
+        enabled: entry.enabled,
+        options: { ...entry.options },
+      });
+    },
+  };
+}
+
+function definitionFromWidgetSpec(spec: WidgetSpecUnion): WidgetDefinition {
+  return {
+    type: spec.type as WidgetType,
+    label: spec.label,
+    category: spec.category as WidgetCategory,
+    description: spec.description,
+  };
+}
+
+export const registry = createWidgetRegistry(WIDGETS);