@herbertgao/pi-extensions 2026.9.19 → 2026.9.20

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

@@ -1,122 +0,0 @@
-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

@@ -1,361 +0,0 @@
-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

@@ -1,223 +0,0 @@
-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);