@asturiu/v0-sdk 0.0.0-stage → 1.0.0

package/src/overlay.ts

@@ -0,0 +1,137 @@
+/**
+ * Wallet overlays (ADR-028): a Customer's renames, layout and custom fields
+ * for one Wallet. Shared by the Engine (validation, the reveal gate) and every
+ * frontend (forms, labels): pure and dependency-free so the Frontend kit can
+ * carry it.
+ */
+
+import { REVEAL_LEVELS, type RevealLevel } from "./reveal.js";
+import type { EntryDefinitionDetail, EntryDefinitionField, FieldValueType } from "./types.js";
+import type { FillMode, LocatorRule } from "./fill.js";
+
+/** The key of a custom field: `x_` and a ULID, generated by the Engine. */
+export const CUSTOM_FIELD_ID = /^x_[0-9A-HJKMNP-TV-Z]{26}$/;
+
+export function isCustomFieldId(value: unknown): value is string {
+  return typeof value === "string" && CUSTOM_FIELD_ID.test(value);
+}
+
+/** How strict a reveal level is: a higher rank asks more of the person. `null` (a plain field) ranks lowest. */
+export function revealRank(level: RevealLevel | null | undefined): number {
+  return level ? REVEAL_LEVELS.indexOf(level) : -1;
+}
+
+/** One custom field of a Wallet overlay. */
+export interface CustomFieldSpec {
+  id: string;
+  /** The Entry type it applies to (`edf` ARID). */
+  entry_definition: string;
+  label: string;
+  description?: string;
+  value_type: FieldValueType;
+  validation?: { pattern?: string; min?: number; max?: number; min_length?: number; max_length?: number; enum?: (string | number | boolean)[] };
+  /** Required on Entries created after it was added, and wherever it holds a value. */
+  required: boolean;
+  secret: boolean;
+  /** Only with `secret`; `click` when absent. Never below the Entry type's `secret_reveal_min`. */
+  reveal?: RevealLevel;
+  searchable: boolean;
+  /** ADR-046, as on a FieldDefinition: the modes allowed (absent: what the Entry type's `custom_filled_by` allows), what an internal reference may point at, the locator rule. */
+  filled_by?: FillMode[];
+  targets?: string[];
+  target_definitions?: string[];
+  locator?: LocatorRule;
+}
+
+/** Order and hidden Tenant fields for one Entry type. `order` lists field keys: `fdf` ARIDs and `x_` ids. */
+export interface OverlayLayout {
+  order?: string[];
+  hidden?: string[];
+}
+
+/** The document `PUT /v0/wallets/{arid}/overlay` takes. A new custom field omits `id`. */
+export interface WalletOverlayInput {
+  renames?: Record<string, string>;
+  layout?: Record<string, OverlayLayout>;
+  fields?: (Omit<CustomFieldSpec, "id" | "required" | "secret" | "searchable"> & { id?: string; required?: boolean; secret?: boolean; searchable?: boolean })[];
+}
+
+/** What the Wallet owner's subscription level allows, and what the overlay uses of it. */
+export interface OverlayAllowance {
+  level: string;
+  rename: boolean;
+  arrange: boolean;
+  secret_fields: boolean;
+  extra_fields: { max: number; used: number };
+  searchable_fields: { max: number; used: number };
+}
+
+/** `GET /v0/wallets/{arid}/overlay`. `arid` and `version` are `null` until the Wallet is first customised. */
+export interface WalletOverlay {
+  wallet: string;
+  arid: string | null;
+  version: number | null;
+  renames: Record<string, string>;
+  layout: Record<string, OverlayLayout>;
+  fields: CustomFieldSpec[];
+  allowance: OverlayAllowance;
+}
+
+/** One field of a form or a view, Tenant or custom, as the overlay presents it. */
+export interface FormField {
+  /** `fdf` ARID for a Tenant field, `x_` id for a custom one. */
+  key: string;
+  custom: boolean;
+  label: string;
+  description?: string;
+  value_type?: FieldValueType;
+  secret: boolean;
+  reveal?: RevealLevel;
+  searchable: boolean;
+  required: boolean;
+  hidden: boolean;
+  /** The Tenant's declaration, for a Tenant field. */
+  definition?: EntryDefinitionField;
+  /** The overlay's spec, for a custom field. */
+  spec?: CustomFieldSpec;
+}
+
+/**
+ * The fields of an Entry type in the order and with the names this Wallet's
+ * overlay gives them: the overlay's `order` first, then the remaining Tenant
+ * fields in the Tenant's order, then the remaining custom fields. Hidden
+ * fields are included and marked; leaving them out is the frontend's choice.
+ */
+export function orderedFormFields(def: Pick<EntryDefinitionDetail, "arid" | "fields">, overlay: Pick<WalletOverlay, "renames" | "layout" | "fields"> | null | undefined): FormField[] {
+  const tenant = def.fields
+    .map((f, i) => ({ f, i }))
+    .sort((a, b) => (a.f.order ?? a.i) - (b.f.order ?? b.i) || a.i - b.i)
+    .map(({ f }): FormField => ({
+      key: f.definition.arid,
+      custom: false,
+      label: overlay?.renames?.[f.definition.arid] ?? f.label ?? f.name ?? f.definition.arid,
+      value_type: f.value_type,
+      secret: !!f.secret,
+      reveal: f.reveal,
+      searchable: !!f.searchable,
+      required: f.required,
+      hidden: false,
+      definition: f,
+    }));
+  const custom = (overlay?.fields ?? [])
+    .filter((s) => s.entry_definition === def.arid)
+    .map((s): FormField => ({ key: s.id, custom: true, label: s.label, description: s.description, value_type: s.value_type, secret: s.secret, reveal: s.secret ? s.reveal ?? "click" : undefined, searchable: s.searchable, required: s.required, hidden: false, spec: s }));
+  const layout = overlay?.layout?.[def.arid];
+  const hidden = new Set(layout?.hidden ?? []);
+  const byKey = new Map([...tenant, ...custom].map((f) => [f.key, f]));
+  const out: FormField[] = [];
+  for (const k of layout?.order ?? []) {
+    const f = byKey.get(k);
+    if (f) {
+      out.push(f);
+      byKey.delete(k);
+    }
+  }
+  for (const f of [...tenant, ...custom]) if (byKey.has(f.key)) out.push(f);
+  return out.map((f) => ({ ...f, hidden: !f.custom && !f.required && hidden.has(f.key) }));
+}

package/src/passes.ts

@@ -0,0 +1,168 @@
+/**
+ * Guest passes (ADR-040): the kinds and states of a pass, the code a person
+ * types, and what a Tenant switches on for its customers' passes. Pure and
+ * dependency-free: the Engine validates with these lists, the Customer
+ * Portal, the Admin UI and a Tenant's app read with them.
+ */
+
+/** `bearer`: a link for anyone, the token in the link. `email`: a code sent to one address, typed on the pass page. */
+export const PASS_KINDS = ["bearer", "email"] as const;
+export type PassKind = (typeof PASS_KINDS)[number];
+
+/** What is stored; `ended`, `expired` and `exhausted` are derived when read (`passState`). */
+export const PASS_STORED_STATES = ["active", "locked", "revoked"] as const;
+export type PassStoredState = (typeof PASS_STORED_STATES)[number];
+
+export const PASS_STATES = ["active", "locked", "revoked", "ended", "expired", "exhausted"] as const;
+export type PassState = (typeof PASS_STATES)[number];
+
+/** A link for anyone opens at once or behind a captcha; an e-mail pass always asks for its code. */
+export const PASS_GATES = ["none", "captcha", "code"] as const;
+export type PassGate = (typeof PASS_GATES)[number];
+
+/** Where an e-mail pass is opened: the Customer Portal's pass page, or the Tenant's own app. */
+export const PASS_PAGES = ["portal", "app"] as const;
+export type PassPage = (typeof PASS_PAGES)[number];
+
+export const PASS_LIMITS = {
+  label: 120,
+  message: 1000,
+  appUrl: 2000,
+  codeFailuresMin: 3,
+  codeFailuresMax: 20,
+  sessionsMax: 50,
+  lifetimeDaysMax: 3650,
+  passesPerLevelMax: 1000,
+  opensMax: 100000,
+} as const;
+
+/**
+ * The derived state of a pass. Terminal states come first, so a pass that is
+ * both expired and locked reads `expired`: only an `active` pass opens.
+ */
+export function passState(p: { stored: PassStoredState; not_after?: string | Date | null; opens: number; max_opens?: number | null; bound?: boolean }, now: number = Date.now()): PassState {
+  if (p.stored === "revoked") return "revoked";
+  if (p.bound) return "ended";
+  if (p.not_after && new Date(p.not_after).getTime() <= now) return "expired";
+  if (p.max_opens != null && p.opens >= p.max_opens) return "exhausted";
+  if (p.stored === "locked") return "locked";
+  return "active";
+}
+
+// ------------------------------------------------------------------ the code
+
+/** 32 capital letters and digits without 0, 1, I and O, so a code read aloud or typed again is not mistaken. */
+export const PASS_CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+/** 8 characters from 32: 40 bits, safe only behind the attempt limit (ADR-040 §6). */
+export const PASS_CODE_LENGTH = 8;
+
+/** What a person typed, as the Engine compares it: capitals, with spaces, dashes and dots dropped. */
+export function normalizePassCode(input: string): string {
+  return input.toUpperCase().replace(/[\s.\-_]+/g, "");
+}
+
+export function isPassCode(value: string): boolean {
+  if (value.length !== PASS_CODE_LENGTH) return false;
+  for (const c of value) if (!PASS_CODE_ALPHABET.includes(c)) return false;
+  return true;
+}
+
+/** `ABCDEFGH` → `ABCD-EFGH`, the way the code is shown in the e-mail. */
+export function formatPassCode(code: string): string {
+  const c = normalizePassCode(code);
+  return c.length === PASS_CODE_LENGTH ? `${c.slice(0, 4)}-${c.slice(4)}` : c;
+}
+
+// ----------------------------------------------------------- Tenant options
+
+/** `Tenant.passes` (ADR-040 §10), every key filled. */
+export interface TenantPassOptions {
+  bearer: boolean;
+  email: boolean;
+  page: PassPage;
+  /** The Tenant app's pass page: links for anyone, the handover, and `page: app`. */
+  app_url: string | null;
+  /** The latest end date a pass may have, in days; `null` also allows passes without an end date. */
+  max_lifetime_days: number | null;
+  code_failure_limit: number;
+  /** The ceiling for live guest sessions per pass. */
+  max_sessions: number;
+}
+
+export function defaultPassOptions(): TenantPassOptions {
+  return { bearer: false, email: false, page: "portal", app_url: null, max_lifetime_days: 30, code_failure_limit: 5, max_sessions: 5 };
+}
+
+/** An http(s) URL without credentials, as a pass may point to; null otherwise. */
+export function passAppUrl(v: unknown): string | null {
+  if (typeof v !== "string" || !v || v.length > PASS_LIMITS.appUrl) return null;
+  try {
+    const u = new URL(v);
+    return (u.protocol === "https:" || u.protocol === "http:") && !u.username && !u.password && !u.hash ? u.toString() : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The rules a set of pass options must keep beyond its shape: an app address
+ * while either kind is on. One entry per problem, with
+ * its path under `passes`; the Engine's Tenant schema reports them as `422`.
+ */
+export function passOptionProblems(raw: unknown): { path: (string | number)[]; message: string }[] {
+  const out: { path: (string | number)[]; message: string }[] = [];
+  if (!raw || typeof raw !== "object") return out;
+  const r = raw as Record<string, unknown>;
+  const on = r.bearer === true || r.email === true;
+  if (r.app_url !== undefined && r.app_url !== null && !passAppUrl(r.app_url)) out.push({ path: ["app_url"], message: "must be an http(s) URL without credentials or a fragment" });
+  else if (on && !passAppUrl(r.app_url)) out.push({ path: ["app_url"], message: "passes need the address of the Tenant app's pass page" });
+  return out;
+}
+
+/**
+ * Stored or presented options as every reader takes them: anything missing or
+ * odd back to its default, so an older record or Interface API never breaks a
+ * page. Passes stay off unless a kind is on and the app address is good.
+ */
+export function resolvePassOptions(raw: unknown): TenantPassOptions {
+  const out = defaultPassOptions();
+  if (!raw || typeof raw !== "object") return out;
+  const r = raw as Record<string, unknown>;
+  out.app_url = passAppUrl(r.app_url);
+  out.bearer = r.bearer === true && !!out.app_url;
+  out.email = r.email === true && !!out.app_url;
+  if (typeof r.page === "string" && (PASS_PAGES as readonly string[]).includes(r.page)) out.page = r.page as PassPage;
+  if (r.max_lifetime_days === null) out.max_lifetime_days = null;
+  else if (isIntIn(r.max_lifetime_days, 1, PASS_LIMITS.lifetimeDaysMax)) out.max_lifetime_days = r.max_lifetime_days as number;
+  if (isIntIn(r.code_failure_limit, PASS_LIMITS.codeFailuresMin, PASS_LIMITS.codeFailuresMax)) out.code_failure_limit = r.code_failure_limit as number;
+  if (isIntIn(r.max_sessions, 1, PASS_LIMITS.sessionsMax)) out.max_sessions = r.max_sessions as number;
+  return out;
+}
+
+/** What the portal needs from `Tenant.passes`, on the public presentation. */
+export interface PassPresentation {
+  email: boolean;
+  page: PassPage;
+  app_url: string | null;
+}
+
+/** The latest end date a new pass may have, or `null` when passes without an end date are allowed. */
+export function passLatestEnd(options: TenantPassOptions, now: number = Date.now()): Date | null {
+  return options.max_lifetime_days === null ? null : new Date(now + options.max_lifetime_days * 86_400_000);
+}
+
+/** The address a link for anyone carries: the app's pass page with the token in the fragment, never sent to a server. */
+export function bearerPassUrl(appUrl: string, token: string): string {
+  return `${appUrl.replace(/#.*$/, "")}#t=${encodeURIComponent(token)}`;
+}
+
+/** The app's pass page with one query parameter added (`handover`, or `pass` for a handle). */
+export function passAppTarget(appUrl: string, key: "handover" | "pass", value: string): string {
+  const u = new URL(appUrl);
+  u.searchParams.set(key, value);
+  return u.toString();
+}
+
+function isIntIn(v: unknown, min: number, max: number): boolean {
+  return typeof v === "number" && Number.isInteger(v) && v >= min && v <= max;
+}

package/src/portal-options.ts

@@ -0,0 +1,125 @@
+/**
+ * Portal options (ADR-037): which pages and parts of the Customer Portal a
+ * Tenant shows, from closed lists. A page can stay in the portal, move to the
+ * Tenant's own application (`redirect`) or, where nothing a person depends on
+ * goes with it, be switched off. Pure and dependency-free: the Engine
+ * validates with these lists, the portal and the Admin UI read with them.
+ */
+
+/** On/off parts, every one on unless switched off. `account_link` predates the rest (components/15). */
+export const PORTAL_SWITCHES = ["account_link", "open_app", "back_link", "language_menu", "appearance"] as const;
+export type PortalSwitch = (typeof PORTAL_SWITCHES)[number];
+
+/** The overview is always there; these are the pages a Tenant may move or switch off. */
+export const PORTAL_PAGES = ["profile", "security", "plan", "privacy", "recovery", "support"] as const;
+export type PortalPage = (typeof PORTAL_PAGES)[number];
+
+export const PORTAL_PAGE_MODES = ["portal", "redirect", "off"] as const;
+export type PortalPageMode = (typeof PORTAL_PAGE_MODES)[number];
+
+/**
+ * Move, never remove: keeping an account safe (`security`) and taking one's
+ * data or leaving (`privacy`) must stay reachable. `plan` may be off only
+ * when the Tenant bills; what the platform bills, the person must be able to
+ * change or cancel (`portalOptionProblems`). `recovery` is the owner's
+ * vault recovery page (ADR-050 §2): switching it off leaves recoveries
+ * already set up working, because the contact, helper and claimant pages
+ * are always on the portal.
+ */
+export const PORTAL_PAGE_ALLOWED: Record<PortalPage, readonly PortalPageMode[]> = {
+  profile: ["portal", "redirect", "off"],
+  security: ["portal", "redirect"],
+  plan: ["portal", "redirect", "off"],
+  privacy: ["portal", "redirect"],
+  recovery: ["portal", "redirect", "off"],
+  // Support (ADR-058 §12, build notes): shown by default, but only while the Tenant keeps tickets with its Customers on; the Interface API reports it off otherwise.
+  support: ["portal", "redirect", "off"],
+};
+
+/** Where each page lives in the portal. */
+export const PORTAL_PAGE_PATHS: Record<PortalPage, string> = { profile: "/profile", security: "/security", plan: "/plan", privacy: "/privacy", recovery: "/recovery", support: "/support" };
+
+export const PORTAL_REDIRECT_URL_MAX = 2000;
+
+export interface PortalPageSetting {
+  mode: PortalPageMode;
+  /** With `redirect` only: an http(s) URL in the Tenant's application. */
+  url?: string;
+}
+
+export type PortalOptions = Record<PortalSwitch, boolean> & { pages: Record<PortalPage, PortalPageSetting> };
+
+export function defaultPortalOptions(): PortalOptions {
+  return {
+    account_link: true,
+    open_app: true,
+    back_link: true,
+    language_menu: true,
+    appearance: true,
+    pages: { profile: { mode: "portal" }, security: { mode: "portal" }, plan: { mode: "portal" }, privacy: { mode: "portal" }, recovery: { mode: "portal" }, support: { mode: "portal" } },
+  };
+}
+
+/** An http(s) URL a portal may send a person to; null otherwise. */
+export function portalRedirectUrl(v: unknown): string | null {
+  if (typeof v !== "string" || !v || v.length > PORTAL_REDIRECT_URL_MAX) return null;
+  try {
+    const u = new URL(v);
+    return (u.protocol === "https:" || u.protocol === "http:") && !u.username && !u.password ? u.toString() : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The rules a stored set of options must keep, beyond its shape: the modes a
+ * page allows, a URL with every redirect and only there, and the plan page
+ * while the platform bills. One entry per problem, with its path under
+ * `portal`. The Engine's Tenant schema reports them as `422`.
+ */
+export function portalOptionProblems(raw: unknown, ctx: { collection?: string } = {}): { path: (string | number)[]; message: string }[] {
+  const out: { path: (string | number)[]; message: string }[] = [];
+  const pages = raw && typeof raw === "object" ? (raw as { pages?: unknown }).pages : undefined;
+  if (!pages || typeof pages !== "object") return out;
+  for (const page of PORTAL_PAGES) {
+    const s = (pages as Record<string, unknown>)[page];
+    if (!s || typeof s !== "object") continue;
+    const { mode, url } = s as { mode?: unknown; url?: unknown };
+    if (typeof mode === "string" && (PORTAL_PAGE_MODES as readonly string[]).includes(mode) && !PORTAL_PAGE_ALLOWED[page].includes(mode as PortalPageMode))
+      out.push({ path: ["pages", page, "mode"], message: `the ${page} page can be moved to the Tenant's application but not switched off` });
+    if (mode === "redirect" && !portalRedirectUrl(url)) out.push({ path: ["pages", page, "url"], message: "a redirect needs an http(s) URL" });
+    if (mode !== "redirect" && url !== undefined) out.push({ path: ["pages", page, "url"], message: "a URL goes with mode redirect only" });
+    if (page === "plan" && mode === "off" && ctx.collection === "connected") out.push({ path: ["pages", "plan", "mode"], message: "while the platform bills, the plan page can be moved but not switched off: a person must be able to change or cancel" });
+  }
+  return out;
+}
+
+/**
+ * Stored or presented options as the portal reads them: every switch and page
+ * filled, anything odd or missing back to its default, so an old record, an
+ * old Interface API or a value that no longer validates never breaks a page.
+ */
+export function resolvePortalOptions(raw: unknown, ctx: { collection?: string } = {}): PortalOptions {
+  const out = defaultPortalOptions();
+  if (!raw || typeof raw !== "object") return out;
+  const r = raw as Record<string, unknown>;
+  for (const k of PORTAL_SWITCHES) if (typeof r[k] === "boolean") out[k] = r[k] as boolean;
+  const pages = r.pages && typeof r.pages === "object" ? (r.pages as Record<string, unknown>) : {};
+  for (const page of PORTAL_PAGES) {
+    const s = pages[page] as { mode?: unknown; url?: unknown } | undefined;
+    if (!s || typeof s !== "object" || typeof s.mode !== "string" || !PORTAL_PAGE_ALLOWED[page].includes(s.mode as PortalPageMode)) continue;
+    if (s.mode === "redirect") {
+      const url = portalRedirectUrl(s.url);
+      if (url) out.pages[page] = { mode: "redirect", url };
+    } else if (!(page === "plan" && s.mode === "off" && ctx.collection === "connected")) out.pages[page] = { mode: s.mode as PortalPageMode };
+  }
+  return out;
+}
+
+/** Where a link to a page goes: the portal's own path, the Tenant's URL (`external`), or nowhere when the page is off. */
+export function portalPageTarget(options: PortalOptions, page: PortalPage): { href: string; external: boolean } | null {
+  const s = options.pages[page];
+  if (s.mode === "off") return null;
+  if (s.mode === "redirect" && s.url) return { href: s.url, external: true };
+  return { href: PORTAL_PAGE_PATHS[page], external: false };
+}

package/src/reads.ts

@@ -0,0 +1,71 @@
+/**
+ * Reading cheaply (Tenant changeset 018). Every Interface API call costs a
+ * round trip and its own Postgres, Redis and OpenBao work, so a screen built
+ * from fewer calls is faster than one built from fast calls.
+ */
+
+/** `GET /v0/events?subjects=…` takes at most this many ARIDs; split a longer list into several calls. */
+export const EVENTS_SUBJECTS_MAX = 100;
+
+/** `GET /v0/notifications/count`: what a badge needs, without reading a Notification. */
+export interface NotificationCount {
+  /** Notifications addressed to the session's Principals. */
+  total: number;
+  /** Of those, the ones not acknowledged yet (`pending`, `delivered` or `failed`). */
+  unacknowledged: number;
+}
+
+/** One backend's share of a request: how many calls and their summed time in milliseconds. */
+export interface ServerTimingEntry {
+  count: number;
+  ms: number;
+}
+
+/**
+ * What one Interface API request cost, read from its `Server-Timing` header.
+ * The stack sends the header only where it is configured to (the local stack
+ * does; production does not). Concurrent calls overlap, so a sum may exceed
+ * `app`.
+ */
+export interface ServerTiming {
+  /** Postgres queries; the time includes any wait for a free connection. */
+  pg: ServerTimingEntry;
+  /** OpenBao requests: decryption, HMACs. A batch of many items is one request. */
+  bao: ServerTimingEntry;
+  /** Redis commands: the session, cached relations, policies and Definitions. */
+  redis: ServerTimingEntry;
+  /** The whole request inside the Interface API, in milliseconds. */
+  app: number;
+}
+
+/**
+ * Parse a `Server-Timing` header from the Interface API (`res.headers.get("server-timing")`
+ * on a kit `Response`). `null` when the header is absent or carries none of its metrics.
+ */
+export function parseServerTiming(header: string | null | undefined): ServerTiming | null {
+  if (!header) return null;
+  const out: ServerTiming = { pg: { count: 0, ms: 0 }, bao: { count: 0, ms: 0 }, redis: { count: 0, ms: 0 }, app: 0 };
+  let seen = false;
+  for (const metric of header.split(",")) {
+    const [name, ...params] = metric.trim().split(";");
+    let dur = 0;
+    let desc = "";
+    for (const p of params) {
+      const eq = p.indexOf("=");
+      if (eq < 0) continue;
+      const key = p.slice(0, eq).trim();
+      const value = p.slice(eq + 1).trim().replace(/^"(.*)"$/, "$1");
+      if (key === "dur") dur = Number(value) || 0;
+      else if (key === "desc") desc = value;
+    }
+    const key = name.trim();
+    if (key === "app") {
+      out.app = dur;
+      seen = true;
+    } else if (key === "pg" || key === "bao" || key === "redis") {
+      out[key] = { count: Number.parseInt(desc, 10) || 0, ms: dur };
+      seen = true;
+    }
+  }
+  return seen ? out : null;
+}

package/src/recovery-words.ts

@@ -0,0 +1,137 @@
+/**
+ * The 2048 words a recovery card is written in (ADR-050 §4): the BIP-39 English
+ * list, unchanged and in its order, so a word's index is its 11-bit value. One
+ * list for every language. Source: github.com/bitcoin/bips, bip-0039/english.txt
+ * (SHA-256 2f5eed53a4727b4bf8880d8f3f199efc90e58503646d9ff8eff3a2ed3b24dbda).
+ */
+export const RECOVERY_WORDS: readonly string[] = (
+  "abandon ability able about above absent absorb abstract absurd abuse access accident account accuse " +
+  "achieve acid acoustic acquire across act action actor actress actual adapt add addict address adjust " +
+  "admit adult advance advice aerobic affair afford afraid again age agent agree ahead aim air airport " +
+  "aisle alarm album alcohol alert alien all alley allow almost alone alpha already also alter always " +
+  "amateur amazing among amount amused analyst anchor ancient anger angle angry animal ankle announce " +
+  "annual another answer antenna antique anxiety any apart apology appear apple approve april arch arctic " +
+  "area arena argue arm armed armor army around arrange arrest arrive arrow art artefact artist artwork ask " +
+  "aspect assault asset assist assume asthma athlete atom attack attend attitude attract auction audit " +
+  "august aunt author auto autumn average avocado avoid awake aware away awesome awful awkward axis baby " +
+  "bachelor bacon badge bag balance balcony ball bamboo banana banner bar barely bargain barrel base basic " +
+  "basket battle beach bean beauty because become beef before begin behave behind believe below belt bench " +
+  "benefit best betray better between beyond bicycle bid bike bind biology bird birth bitter black blade " +
+  "blame blanket blast bleak bless blind blood blossom blouse blue blur blush board boat body boil bomb " +
+  "bone bonus book boost border boring borrow boss bottom bounce box boy bracket brain brand brass brave " +
+  "bread breeze brick bridge brief bright bring brisk broccoli broken bronze broom brother brown brush " +
+  "bubble buddy budget buffalo build bulb bulk bullet bundle bunker burden burger burst bus business busy " +
+  "butter buyer buzz cabbage cabin cable cactus cage cake call calm camera camp can canal cancel candy " +
+  "cannon canoe canvas canyon capable capital captain car carbon card cargo carpet carry cart case cash " +
+  "casino castle casual cat catalog catch category cattle caught cause caution cave ceiling celery cement " +
+  "census century cereal certain chair chalk champion change chaos chapter charge chase chat cheap check " +
+  "cheese chef cherry chest chicken chief child chimney choice choose chronic chuckle chunk churn cigar " +
+  "cinnamon circle citizen city civil claim clap clarify claw clay clean clerk clever click client cliff " +
+  "climb clinic clip clock clog close cloth cloud clown club clump cluster clutch coach coast coconut code " +
+  "coffee coil coin collect color column combine come comfort comic common company concert conduct confirm " +
+  "congress connect consider control convince cook cool copper copy coral core corn correct cost cotton " +
+  "couch country couple course cousin cover coyote crack cradle craft cram crane crash crater crawl crazy " +
+  "cream credit creek crew cricket crime crisp critic crop cross crouch crowd crucial cruel cruise crumble " +
+  "crunch crush cry crystal cube culture cup cupboard curious current curtain curve cushion custom cute " +
+  "cycle dad damage damp dance danger daring dash daughter dawn day deal debate debris decade december " +
+  "decide decline decorate decrease deer defense define defy degree delay deliver demand demise denial " +
+  "dentist deny depart depend deposit depth deputy derive describe desert design desk despair destroy " +
+  "detail detect develop device devote diagram dial diamond diary dice diesel diet differ digital dignity " +
+  "dilemma dinner dinosaur direct dirt disagree discover disease dish dismiss disorder display distance " +
+  "divert divide divorce dizzy doctor document dog doll dolphin domain donate donkey donor door dose double " +
+  "dove draft dragon drama drastic draw dream dress drift drill drink drip drive drop drum dry duck dumb " +
+  "dune during dust dutch duty dwarf dynamic eager eagle early earn earth easily east easy echo ecology " +
+  "economy edge edit educate effort egg eight either elbow elder electric elegant element elephant elevator " +
+  "elite else embark embody embrace emerge emotion employ empower empty enable enact end endless endorse " +
+  "enemy energy enforce engage engine enhance enjoy enlist enough enrich enroll ensure enter entire entry " +
+  "envelope episode equal equip era erase erode erosion error erupt escape essay essence estate eternal " +
+  "ethics evidence evil evoke evolve exact example excess exchange excite exclude excuse execute exercise " +
+  "exhaust exhibit exile exist exit exotic expand expect expire explain expose express extend extra eye " +
+  "eyebrow fabric face faculty fade faint faith fall false fame family famous fan fancy fantasy farm " +
+  "fashion fat fatal father fatigue fault favorite feature february federal fee feed feel female fence " +
+  "festival fetch fever few fiber fiction field figure file film filter final find fine finger finish fire " +
+  "firm first fiscal fish fit fitness fix flag flame flash flat flavor flee flight flip float flock floor " +
+  "flower fluid flush fly foam focus fog foil fold follow food foot force forest forget fork fortune forum " +
+  "forward fossil foster found fox fragile frame frequent fresh friend fringe frog front frost frown frozen " +
+  "fruit fuel fun funny furnace fury future gadget gain galaxy gallery game gap garage garbage garden " +
+  "garlic garment gas gasp gate gather gauge gaze general genius genre gentle genuine gesture ghost giant " +
+  "gift giggle ginger giraffe girl give glad glance glare glass glide glimpse globe gloom glory glove glow " +
+  "glue goat goddess gold good goose gorilla gospel gossip govern gown grab grace grain grant grape grass " +
+  "gravity great green grid grief grit grocery group grow grunt guard guess guide guilt guitar gun gym " +
+  "habit hair half hammer hamster hand happy harbor hard harsh harvest hat have hawk hazard head health " +
+  "heart heavy hedgehog height hello helmet help hen hero hidden high hill hint hip hire history hobby " +
+  "hockey hold hole holiday hollow home honey hood hope horn horror horse hospital host hotel hour hover " +
+  "hub huge human humble humor hundred hungry hunt hurdle hurry hurt husband hybrid ice icon idea identify " +
+  "idle ignore ill illegal illness image imitate immense immune impact impose improve impulse inch include " +
+  "income increase index indicate indoor industry infant inflict inform inhale inherit initial inject " +
+  "injury inmate inner innocent input inquiry insane insect inside inspire install intact interest into " +
+  "invest invite involve iron island isolate issue item ivory jacket jaguar jar jazz jealous jeans jelly " +
+  "jewel job join joke journey joy judge juice jump jungle junior junk just kangaroo keen keep ketchup key " +
+  "kick kid kidney kind kingdom kiss kit kitchen kite kitten kiwi knee knife knock know lab label labor " +
+  "ladder lady lake lamp language laptop large later latin laugh laundry lava law lawn lawsuit layer lazy " +
+  "leader leaf learn leave lecture left leg legal legend leisure lemon lend length lens leopard lesson " +
+  "letter level liar liberty library license life lift light like limb limit link lion liquid list little " +
+  "live lizard load loan lobster local lock logic lonely long loop lottery loud lounge love loyal lucky " +
+  "luggage lumber lunar lunch luxury lyrics machine mad magic magnet maid mail main major make mammal man " +
+  "manage mandate mango mansion manual maple marble march margin marine market marriage mask mass master " +
+  "match material math matrix matter maximum maze meadow mean measure meat mechanic medal media melody melt " +
+  "member memory mention menu mercy merge merit merry mesh message metal method middle midnight milk " +
+  "million mimic mind minimum minor minute miracle mirror misery miss mistake mix mixed mixture mobile " +
+  "model modify mom moment monitor monkey monster month moon moral more morning mosquito mother motion " +
+  "motor mountain mouse move movie much muffin mule multiply muscle museum mushroom music must mutual " +
+  "myself mystery myth naive name napkin narrow nasty nation nature near neck need negative neglect neither " +
+  "nephew nerve nest net network neutral never news next nice night noble noise nominee noodle normal north " +
+  "nose notable note nothing notice novel now nuclear number nurse nut oak obey object oblige obscure " +
+  "observe obtain obvious occur ocean october odor off offer office often oil okay old olive olympic omit " +
+  "once one onion online only open opera opinion oppose option orange orbit orchard order ordinary organ " +
+  "orient original orphan ostrich other outdoor outer output outside oval oven over own owner oxygen oyster " +
+  "ozone pact paddle page pair palace palm panda panel panic panther paper parade parent park parrot party " +
+  "pass patch path patient patrol pattern pause pave payment peace peanut pear peasant pelican pen penalty " +
+  "pencil people pepper perfect permit person pet phone photo phrase physical piano picnic picture piece " +
+  "pig pigeon pill pilot pink pioneer pipe pistol pitch pizza place planet plastic plate play please pledge " +
+  "pluck plug plunge poem poet point polar pole police pond pony pool popular portion position possible " +
+  "post potato pottery poverty powder power practice praise predict prefer prepare present pretty prevent " +
+  "price pride primary print priority prison private prize problem process produce profit program project " +
+  "promote proof property prosper protect proud provide public pudding pull pulp pulse pumpkin punch pupil " +
+  "puppy purchase purity purpose purse push put puzzle pyramid quality quantum quarter question quick quit " +
+  "quiz quote rabbit raccoon race rack radar radio rail rain raise rally ramp ranch random range rapid rare " +
+  "rate rather raven raw razor ready real reason rebel rebuild recall receive recipe record recycle reduce " +
+  "reflect reform refuse region regret regular reject relax release relief rely remain remember remind " +
+  "remove render renew rent reopen repair repeat replace report require rescue resemble resist resource " +
+  "response result retire retreat return reunion reveal review reward rhythm rib ribbon rice rich ride " +
+  "ridge rifle right rigid ring riot ripple risk ritual rival river road roast robot robust rocket romance " +
+  "roof rookie room rose rotate rough round route royal rubber rude rug rule run runway rural sad saddle " +
+  "sadness safe sail salad salmon salon salt salute same sample sand satisfy satoshi sauce sausage save say " +
+  "scale scan scare scatter scene scheme school science scissors scorpion scout scrap screen script scrub " +
+  "sea search season seat second secret section security seed seek segment select sell seminar senior sense " +
+  "sentence series service session settle setup seven shadow shaft shallow share shed shell sheriff shield " +
+  "shift shine ship shiver shock shoe shoot shop short shoulder shove shrimp shrug shuffle shy sibling sick " +
+  "side siege sight sign silent silk silly silver similar simple since sing siren sister situate six size " +
+  "skate sketch ski skill skin skirt skull slab slam sleep slender slice slide slight slim slogan slot slow " +
+  "slush small smart smile smoke smooth snack snake snap sniff snow soap soccer social sock soda soft solar " +
+  "soldier solid solution solve someone song soon sorry sort soul sound soup source south space spare " +
+  "spatial spawn speak special speed spell spend sphere spice spider spike spin spirit split spoil sponsor " +
+  "spoon sport spot spray spread spring spy square squeeze squirrel stable stadium staff stage stairs stamp " +
+  "stand start state stay steak steel stem step stereo stick still sting stock stomach stone stool story " +
+  "stove strategy street strike strong struggle student stuff stumble style subject submit subway success " +
+  "such sudden suffer sugar suggest suit summer sun sunny sunset super supply supreme sure surface surge " +
+  "surprise surround survey suspect sustain swallow swamp swap swarm swear sweet swift swim swing switch " +
+  "sword symbol symptom syrup system table tackle tag tail talent talk tank tape target task taste tattoo " +
+  "taxi teach team tell ten tenant tennis tent term test text thank that theme then theory there they thing " +
+  "this thought three thrive throw thumb thunder ticket tide tiger tilt timber time tiny tip tired tissue " +
+  "title toast tobacco today toddler toe together toilet token tomato tomorrow tone tongue tonight tool " +
+  "tooth top topic topple torch tornado tortoise toss total tourist toward tower town toy track trade " +
+  "traffic tragic train transfer trap trash travel tray treat tree trend trial tribe trick trigger trim " +
+  "trip trophy trouble truck true truly trumpet trust truth try tube tuition tumble tuna tunnel turkey turn " +
+  "turtle twelve twenty twice twin twist two type typical ugly umbrella unable unaware uncle uncover under " +
+  "undo unfair unfold unhappy uniform unique unit universe unknown unlock until unusual unveil update " +
+  "upgrade uphold upon upper upset urban urge usage use used useful useless usual utility vacant vacuum " +
+  "vague valid valley valve van vanish vapor various vast vault vehicle velvet vendor venture venue verb " +
+  "verify version very vessel veteran viable vibrant vicious victory video view village vintage violin " +
+  "virtual virus visa visit visual vital vivid vocal voice void volcano volume vote voyage wage wagon wait " +
+  "walk wall walnut want warfare warm warrior wash wasp waste water wave way wealth weapon wear weasel " +
+  "weather web wedding weekend weird welcome west wet whale what wheat wheel when where whip whisper wide " +
+  "width wife wild will win window wine wing wink winner winter wire wisdom wise wish witness wolf woman " +
+  "wonder wood wool word work world worry worth wrap wreck wrestle wrist write wrong yard year yellow you " +
+  "young youth zebra zero zone zoo"
+).split(" ");