entangled-worlds-orbiters-shared 4.2.0 → 5.0.0

package/src/shortcuts/labels.ts

@@ -1,139 +0,0 @@
-// What the actions and sections are called in each language the platform speaks, beside the
-// English in the catalogues. One table, read by every app and the settings page, so a name is
-// translated once.
-
-import type { ShortcutAction } from './match.js'
-
-type Names = Readonly<Record<string, string>>
-
-const ES: Names = Object.freeze({
-  "ew.player.playPause": "Reproducir o pausar",
-  "ew.studio.commands": "Comandos",
-  "ew.studio.copy": "Copiar la selección",
-  "ew.studio.duplicate": "Duplicar la selección",
-  "ew.studio.help": "Atajos de teclado",
-  "ew.studio.paste": "Pegar",
-  "ew.studio.playPause": "Reproducir o pausar",
-  "ew.studio.redo": "Rehacer",
-  "ew.studio.remove": "Quitar la selección",
-  "ew.studio.step.animations": "Paso de animaciones",
-  "ew.studio.step.audio": "Paso de audio",
-  "ew.studio.step.release": "Paso de publicación",
-  "ew.studio.step.third": "Paso de exportación (Publicación donde no hay exportación)",
-  "ew.studio.undo": "Deshacer",
-  "orbiters.play.body.moon": "Luna",
-  "orbiters.play.body.star": "Estrella",
-  "orbiters.play.body.world": "Mundo",
-  "orbiters.play.dimension.1": "Primera dimensión",
-  "orbiters.play.dimension.2": "Segunda dimensión",
-  "orbiters.play.dimension.3": "Tercera dimensión",
-  "orbiters.play.help": "Atajos de teclado",
-  "orbiters.play.history.redo": "Rehacer",
-  "orbiters.play.history.undo": "Deshacer",
-  "orbiters.play.midiLearn": "MIDI learn",
-  "orbiters.play.panel.cosmicLfo": "Cosmic LFO",
-  "orbiters.play.panel.jamming": "Jamming",
-  "orbiters.play.panel.playback": "Reproducción",
-  "orbiters.play.panel.sensors": "Sensores",
-  "orbiters.play.performanceMode": "Modo rendimiento",
-  "orbiters.play.rec.hold": "Grabar mientras se mantiene",
-  "orbiters.play.rec.toggle": "Activar o desactivar Rec",
-  "orbiters.play.snapshot.recall.0": "Recuperar instantánea 0",
-  "orbiters.play.snapshot.recall.1": "Recuperar instantánea 1",
-  "orbiters.play.snapshot.recall.2": "Recuperar instantánea 2",
-  "orbiters.play.snapshot.recall.3": "Recuperar instantánea 3",
-  "orbiters.play.snapshot.recall.4": "Recuperar instantánea 4",
-  "orbiters.play.snapshot.recall.5": "Recuperar instantánea 5",
-  "orbiters.play.snapshot.recall.6": "Recuperar instantánea 6",
-  "orbiters.play.snapshot.recall.7": "Recuperar instantánea 7",
-  "orbiters.play.snapshot.recall.8": "Recuperar instantánea 8",
-  "orbiters.play.snapshot.recall.9": "Recuperar instantánea 9",
-  "orbiters.play.snapshot.store.0": "Guardar instantánea 0",
-  "orbiters.play.snapshot.store.1": "Guardar instantánea 1",
-  "orbiters.play.snapshot.store.2": "Guardar instantánea 2",
-  "orbiters.play.snapshot.store.3": "Guardar instantánea 3",
-  "orbiters.play.snapshot.store.4": "Guardar instantánea 4",
-  "orbiters.play.snapshot.store.5": "Guardar instantánea 5",
-  "orbiters.play.snapshot.store.6": "Guardar instantánea 6",
-  "orbiters.play.snapshot.store.7": "Guardar instantánea 7",
-  "orbiters.play.snapshot.store.8": "Guardar instantánea 8",
-  "orbiters.play.snapshot.store.9": "Guardar instantánea 9",
-  "orbiters.play.transport.restart": "Reproducir desde el principio",
-  "orbiters.play.transport.toggle": "Reproducir o pausar",
-  "orbiters.studio.map": "Mapear",
-  "orbiters.studio.redo": "Rehacer",
-  "orbiters.studio.undo": "Deshacer",
-  "site.commands": "Comandos",
-  "site.search": "Buscar",
-  "site.go.home": "Inicio",
-  "site.go.playground": "Playground",
-  "site.go.notifications": "Notificaciones",
-  "site.go.audios": "Mis audios",
-  "site.go.orbiters": "Mis Orbiters",
-  "site.go.worlds": "Mis Entangled Worlds",
-  "site.go.collections": "Mis colecciones",
-  "site.go.stars": "Mis estrellas",
-  "site.new.orbiter": "Nuevo Orbiter",
-  "site.new.audio": "Nuevo audio",
-  "site.new.world": "Nuevo Entangled World",
-  "site.settings": "Abrir la configuración",
-  "section:site": "Plantasia Space",
-  "app:plantasia-space": "Plantasia Space",
-  "app:orbiters": "Orbiters",
-  "app:entangled-worlds": "Entangled Worlds",
-  "part:orbiters-play": "Tocar",
-  "part:orbiters-studio": "Estudio",
-  "part:ew-studio": "Estudio",
-  "part:ew-player": "Reproductor",
-  "section:orbiters-play": "Orbiters: tocar",
-  "section:orbiters-studio": "Orbiter Studio",
-  "section:ew-studio": "Estudio de Entangled Worlds",
-  "section:ew-player": "Reproductor de Entangled Worlds",
-  "orbiters.play.screenCapture": "Captura de pantalla",
-  "orbiters.play.share": "Compartir",
-  "orbiters.play.fullscreen": "Pantalla completa",
-  "orbiters.play.commands": "Comandos",
-  "group:edit": "Edición",
-  "group:playback": "Reproducción",
-  "group:steps": "Pasos",
-  "group:help": "Ayuda",
-  "group:transport": "Transporte",
-  "group:view": "Vista",
-  "group:snapshots": "Instantáneas",
-  "group:panels": "Paneles",
-  "group:orbiter": "Orbiter",
-  "group:studio": "Estudio",
-  "row:playPause": "Reproducir / pausar",
-  "row:playFromStart": "Reproducir desde el inicio",
-  "row:recHeld": "REC mientras se mantiene",
-  "row:recLatch": "REC fijo",
-  "row:undo": "Deshacer",
-  "row:redo": "Rehacer",
-  "row:dimensions": "Dimensión I · II · III",
-  "row:bodies": "Mundo · Luna · Estrella",
-  "row:snapshotRecall": "Recuperar instantánea",
-  "row:snapshotStore": "Guardar instantánea",
-  "row:jamming": "Jamming",
-  "row:playback": "Reproducción",
-  "row:cosmicLfo": "Cosmic LFO",
-  "row:sensors": "Sensores",
-  "row:midiLearn": "MIDI learn",
-  "row:performanceMode": "Modo rendimiento",
-})
-
-const NAMES: Readonly<Record<string, Names>> = Object.freeze({ es: ES })
-
-/** An action's name in a language (`es`, `es-AR`), falling back to the catalogue's English. */
-export function shortcutLabel(action: Pick<ShortcutAction, 'id' | 'label'>, locale?: string): string {
-  return NAMES[(locale ?? '').slice(0, 2).toLowerCase()]?.[action.id] ?? action.label
-}
-
-/** A section's name in a language, falling back to the English. */
-export function shortcutSectionLabel(section: { id: string; label: string }, locale?: string): string {
-  return NAMES[(locale ?? '').slice(0, 2).toLowerCase()]?.[`section:${section.id}`] ?? section.label
-}
-
-/** Any other named thing of the shortcuts (a command group `group:<id>`, a sheet row `row:<id>`). */
-export function shortcutName(key: string, english: string, locale?: string): string {
-  return NAMES[(locale ?? '').slice(0, 2).toLowerCase()]?.[key] ?? english
-}

package/src/shortcuts/orbiters.ts

@@ -1,132 +0,0 @@
-// The Orbiters catalogues: every key Orbiters answers, with the keys it has by default.
-//
-// `voice` acts on the focused deck(s), so in a shared session it only reaches a deck this person
-// holds; `client` is about this machine and no deck (MIDI learn, performance mode, the Studio).
-
-import type { ShortcutAction } from './match.js'
-
-export type OrbitersShortcutScope = 'voice' | 'client'
-export type OrbitersShortcut = ShortcutAction<OrbitersShortcutScope>
-
-export const ORBITERS_PLAY_SECTION = 'orbiters-play'
-export const ORBITERS_STUDIO_SECTION = 'orbiters-studio'
-
-interface ActionOptions {
-  scope?: OrbitersShortcutScope
-  group?: string
-  command?: boolean
-}
-
-const play = (id: string, label: string, defaultKeys: readonly string[], { scope = 'voice', group, command }: ActionOptions = {}): OrbitersShortcut =>
-  Object.freeze({
-    id: `orbiters.play.${id}`, section: ORBITERS_PLAY_SECTION, label, defaultKeys: Object.freeze([...defaultKeys]), scope,
-    ...(group ? { group } : {}), ...(command === false ? { command } : {}),
-  })
-
-const studio = (id: string, label: string, defaultKeys: readonly string[]): OrbitersShortcut =>
-  Object.freeze({ id: `orbiters.studio.${id}`, section: ORBITERS_STUDIO_SECTION, label, defaultKeys: Object.freeze([...defaultKeys]), scope: 'client', group: 'studio' })
-
-/** How a command menu groups the actions, in its order. */
-export const ORBITERS_COMMAND_GROUPS = Object.freeze([
-  { id: 'transport', label: 'Transport' },
-  { id: 'view', label: 'View' },
-  { id: 'snapshots', label: 'Snapshots' },
-  { id: 'panels', label: 'Panels' },
-  { id: 'orbiter', label: 'Orbiter' },
-  { id: 'studio', label: 'Studio' },
-] as const)
-
-/** The snapshot slots, by the number each shows: the number row, 1 to 9, then 0. */
-const SLOT_NUMBERS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
-
-/** Undo and redo, the same keys wherever an edit can be taken back. */
-const UNDO_KEYS = ['Mod+KeyZ']
-const REDO_KEYS = ['Mod+Shift+KeyZ', 'Ctrl+Shift?+KeyY']
-
-/**
- * Playing an Orbiter. Shift is free on most keys (`Shift?`): it is held to select several decks,
- * and a key pressed while selecting means what it means alone.
- */
-export const ORBITERS_PLAY_SHORTCUTS: readonly OrbitersShortcut[] = Object.freeze([
-  // Space takes Ctrl, Option and ⌘ as it comes: only Shift changes what it does.
-  play('transport.toggle', 'Play or pause', ['Alt?+Ctrl?+Meta?+Space'], { group: 'transport' }),
-  play('transport.restart', 'Play from the beginning', ['Shift+Alt?+Ctrl?+Meta?+Space'], { group: 'transport' }),
-  play('rec.hold', 'Record while held', ['KeyR'], { group: 'transport', command: false }),
-  play('rec.toggle', 'Rec on or off', ['Shift+KeyR'], { group: 'transport' }),
-  play('history.undo', 'Undo', UNDO_KEYS, { group: 'transport' }),
-  play('history.redo', 'Redo', REDO_KEYS, { group: 'transport' }),
-  play('dimension.1', 'First dimension', ['Shift?+Digit1'], { group: 'view' }),
-  play('dimension.2', 'Second dimension', ['Shift?+Digit2'], { group: 'view' }),
-  play('dimension.3', 'Third dimension', ['Shift?+Digit3'], { group: 'view' }),
-  play('body.world', 'World', ['Shift?+KeyQ'], { group: 'view' }),
-  play('body.moon', 'Moon', ['Shift?+KeyW'], { group: 'view' }),
-  play('body.star', 'Star', ['Shift?+KeyE'], { group: 'view' }),
-  ...SLOT_NUMBERS.map((n) => play(`snapshot.recall.${n}`, `Recall snapshot ${n}`, [`Alt+Digit${n}`], { group: 'snapshots' })),
-  ...SLOT_NUMBERS.map((n) => play(`snapshot.store.${n}`, `Store snapshot ${n}`, [`Alt+Shift+Digit${n}`], { group: 'snapshots' })),
-  // The panels, from the bottom of the rail up.
-  play('panel.jamming', 'Jamming', ['KeyA'], { group: 'panels' }),
-  play('panel.playback', 'Playback', ['KeyS'], { group: 'panels' }),
-  play('panel.cosmicLfo', 'Cosmic LFO', ['KeyD'], { group: 'panels' }),
-  play('panel.sensors', 'Sensors', ['KeyF'], { group: 'panels' }),
-  // The More menu, and this machine's switches.
-  play('midiLearn', 'MIDI learn', ['Shift?+KeyM'], { scope: 'client', group: 'orbiter' }),
-  play('performanceMode', 'Performance mode', ['Shift?+KeyP'], { scope: 'client', group: 'orbiter' }),
-  play('screenCapture', 'Screen capture', [], { scope: 'client', group: 'orbiter' }),
-  play('share', 'Share', [], { scope: 'client', group: 'orbiter' }),
-  play('fullscreen', 'Fullscreen', [], { scope: 'client', group: 'orbiter' }),
-  // `?` on a US keyboard: the key's place, whatever this keyboard prints there.
-  play('help', 'Keyboard shortcuts', ['Shift?+Slash'], { scope: 'client', group: 'orbiter', command: false }),
-  play('commands', 'Commands', ['Mod+KeyK'], { scope: 'client', group: 'orbiter', command: false }),
-])
-
-/**
- * The keys sheet (`?`): what to look up at a glance, in three columns. A row may stand for several
- * actions whose keys differ only in the last key ("Dimension I · II · III — 1 2 3"); the keys
- * shown are always this person's (`mergedKeyParts`).
- */
-export const ORBITERS_PLAY_SHEET = Object.freeze([
-  { id: 'transport', label: 'Transport', rows: [
-    { id: 'playPause', label: 'Play / pause', actions: ['transport.toggle'] },
-    { id: 'playFromStart', label: 'Play from start', actions: ['transport.restart'] },
-    { id: 'recHeld', label: 'REC while held', actions: ['rec.hold'] },
-    { id: 'recLatch', label: 'REC latch', actions: ['rec.toggle'] },
-    { id: 'undo', label: 'Undo', actions: ['history.undo'] },
-    { id: 'redo', label: 'Redo', actions: ['history.redo'] },
-  ] },
-  { id: 'view', label: 'View', rows: [
-    { id: 'dimensions', label: 'Dimension I · II · III', actions: ['dimension.1', 'dimension.2', 'dimension.3'] },
-    { id: 'bodies', label: 'World · Moon · Star', actions: ['body.world', 'body.moon', 'body.star'] },
-    { id: 'snapshotRecall', label: 'Snapshot recall', actions: SLOT_NUMBERS.map((n) => `snapshot.recall.${n}`) },
-    { id: 'snapshotStore', label: 'Snapshot store', actions: SLOT_NUMBERS.map((n) => `snapshot.store.${n}`) },
-  ] },
-  { id: 'panels', label: 'Panels', rows: [
-    { id: 'jamming', label: 'Jamming', actions: ['panel.jamming'] },
-    { id: 'playback', label: 'Playback', actions: ['panel.playback'] },
-    { id: 'cosmicLfo', label: 'Cosmic LFO', actions: ['panel.cosmicLfo'] },
-    { id: 'sensors', label: 'Sensors', actions: ['panel.sensors'] },
-    { id: 'midiLearn', label: 'MIDI learn', actions: ['midiLearn'] },
-    { id: 'performanceMode', label: 'Performance mode', actions: ['performanceMode'] },
-  ] },
-].map((column) => Object.freeze({
-  ...column,
-  rows: Object.freeze(column.rows.map((row) => Object.freeze({ ...row, actions: Object.freeze(row.actions.map((a) => `orbiters.play.${a}`)) }))),
-})))
-
-/**
- * The Studio. It is open over play, so the play keys above still work there; where both name a key,
- * the Studio's action is the one.
- */
-export const ORBITERS_STUDIO_SHORTCUTS: readonly OrbitersShortcut[] = Object.freeze([
-  studio('undo', 'Undo', UNDO_KEYS),
-  studio('redo', 'Redo', REDO_KEYS),
-  studio('map', 'Map', ['Shift+KeyM']),
-])
-
-/**
- * The letters the on-screen keyboard plays while it is open (`event.key`, lower-case): the piano row,
- * then Z and X for the octave and C and V for velocity. While it is up they are its notes, and the
- * shortcuts on them wait (`claimKeys`); a settings page says so beside those keys.
- */
-export const ORBITERS_KEYBOARD_SURFACE_KEYS: readonly string[] = Object.freeze([
-  'a', 'w', 's', 'e', 'd', 'f', 't', 'g', 'y', 'h', 'u', 'j', 'k', 'o', 'l', 'p', ';', "'", 'z', 'x', 'c', 'v',
-])

package/src/shortcuts/overrides.ts

@@ -1,110 +0,0 @@
-// A person's shortcut overrides, read the same way by every app: from their account when signed in
-// (someone signed out has the default keys), and again whenever the page comes back to the front (a key changed
-// on the settings page applies on return, without a reload).
-//
-// Framework-free: the app hands in how it reads the account (its own API client) and gets the
-// overrides and each catalogue's resolved keys back, kept until the overrides change.
-
-import { resolveBindings, type ShortcutAction, type ShortcutOverrides } from './match.js'
-
-/** The overrides in a stored value, or `null` when it is not a list of `{ id, keys }`. */
-export function parseOverrides(value: unknown): ShortcutOverrides | null {
-  if (!Array.isArray(value)) return null
-  return value.filter(
-    (entry): entry is { id: string; keys: string[] } =>
-      !!entry && typeof entry.id === 'string' && Array.isArray(entry.keys) && entry.keys.every((k: unknown) => typeof k === 'string'),
-  )
-}
-
-/**
- * How the app reads the signed-in person's settings: `null` when no one is signed in (the
- * default keys); `undefined` when the read failed (the overrides in force are kept: a blip must not
- * swap someone's keys for the defaults).
- */
-export type ReadAccountSettings = (options: { fresh: boolean }) => Promise<{ shortcuts?: unknown } | null | undefined>
-
-export interface ShortcutOverridesSource {
-  /** The overrides in force. */
-  get(): ShortcutOverrides
-  /** A catalogue's actions with their keys now (kept until the overrides change). */
-  bindings(catalogue: readonly ShortcutAction[]): Map<string, readonly string[]>
-  /** Called whenever the overrides change; returns the unsubscribe. */
-  subscribe(listener: () => void): () => void
-  /** Read again (`fresh`: past the app's own cached read). The newest read wins, whatever order they end in. */
-  refresh(options?: { fresh?: boolean }): Promise<void>
-  /** Read now, and again whenever the page comes back to the front; once per source. */
-  bind(): void
-  /** For tests: set the overrides directly. */
-  set(overrides: ShortcutOverrides): void
-}
-
-/** Coming back to the front twice in a row (visible, then focus) asks the account once. */
-const REFRESH_GAP_MS = 2000
-
-export function createShortcutOverridesSource(readAccount: ReadAccountSettings): ShortcutOverridesSource {
-  let overrides: ShortcutOverrides = []
-  let resolved = new WeakMap<readonly ShortcutAction[], Map<string, readonly string[]>>()
-  let latest = 0
-  let applied = 0
-  let lastRefreshAt = -Infinity
-  let bound = false
-  const listeners = new Set<() => void>()
-
-  const apply = (next: ShortcutOverrides) => {
-    if (JSON.stringify(next) === JSON.stringify(overrides)) return
-    overrides = next
-    resolved = new WeakMap()
-    listeners.forEach((listener) => listener())
-  }
-
-  const refresh = async ({ fresh = false }: { fresh?: boolean } = {}) => {
-    const ticket = ++latest
-    lastRefreshAt = Date.now()
-    let settings: { shortcuts?: unknown } | null | undefined
-    try {
-      settings = await readAccount({ fresh })
-    } catch {
-      settings = undefined
-    }
-    // The newest read that answered wins: an older one ending after it says nothing new, and a newer
-    // one that failed does not throw away an older one's answer.
-    if (settings === undefined || ticket < applied) return
-    applied = ticket
-    apply(settings === null ? [] : (parseOverrides(settings.shortcuts) ?? []))
-  }
-
-  return {
-    get: () => overrides,
-    bindings(catalogue) {
-      let map = resolved.get(catalogue)
-      if (!map) {
-        map = resolveBindings(catalogue, overrides)
-        resolved.set(catalogue, map)
-      }
-      return map
-    },
-    subscribe(listener) {
-      listeners.add(listener)
-      return () => {
-        listeners.delete(listener)
-      }
-    },
-    refresh,
-    bind() {
-      const win = globalThis as unknown as {
-        addEventListener?: (type: string, fn: () => void) => void
-        document?: { visibilityState?: string; addEventListener?: (type: string, fn: () => void) => void }
-      }
-      if (bound || typeof win.addEventListener !== 'function' || !win.document?.addEventListener) return
-      bound = true
-      void refresh()
-      const onFront = () => {
-        if (win.document?.visibilityState !== 'visible' || Date.now() - lastRefreshAt < REFRESH_GAP_MS) return
-        void refresh({ fresh: true })
-      }
-      win.document.addEventListener('visibilitychange', onFront)
-      win.addEventListener('focus', onFront)
-    },
-    set: apply,
-  }
-}

package/src/shortcuts/sections.ts

@@ -1,36 +0,0 @@
-// Every app's catalogue in one place, in the order a settings page shows them. A section is one
-// surface's keys; two actions may share a key only across sections (the Orbiter Studio lies over
-// play, and takes ⌘Z from it while it is open).
-
-import type { ShortcutAction } from './match.js'
-import { EW_PLAYER_SECTION, EW_PLAYER_SHORTCUTS, EW_STUDIO_SECTION, EW_STUDIO_SHORTCUTS } from './entangledWorlds.js'
-import { ORBITERS_PLAY_SECTION, ORBITERS_PLAY_SHORTCUTS, ORBITERS_STUDIO_SECTION, ORBITERS_STUDIO_SHORTCUTS } from './orbiters.js'
-import { SITE_SECTION, SITE_SHORTCUTS } from './site.js'
-
-/** The apps a person tells apart, in the order a settings page shows them. */
-export const SHORTCUT_APPS = Object.freeze([
-  Object.freeze({ id: 'plantasia-space', label: 'Plantasia Space' }),
-  Object.freeze({ id: 'orbiters', label: 'Orbiters' }),
-  Object.freeze({ id: 'entangled-worlds', label: 'Entangled Worlds' }),
-] as const)
-
-export type ShortcutAppId = (typeof SHORTCUT_APPS)[number]['id']
-
-export interface ShortcutSection {
-  readonly id: string
-  readonly label: string
-  /** The app it belongs to. */
-  readonly app: ShortcutAppId
-  /** Its name inside that app (`Play`, `Studio`); none when the app has only this section. */
-  readonly part?: string
-  readonly actions: readonly ShortcutAction[]
-}
-
-export const SHORTCUT_SECTIONS: readonly ShortcutSection[] = Object.freeze<ShortcutSection[]>([
-  Object.freeze({ id: SITE_SECTION, label: 'Plantasia Space', app: 'plantasia-space', actions: SITE_SHORTCUTS }),
-  Object.freeze({ id: ORBITERS_PLAY_SECTION, label: 'Orbiters play', app: 'orbiters', part: 'Play', actions: ORBITERS_PLAY_SHORTCUTS }),
-  Object.freeze({ id: ORBITERS_STUDIO_SECTION, label: 'Orbiter Studio', app: 'orbiters', part: 'Studio', actions: ORBITERS_STUDIO_SHORTCUTS }),
-  Object.freeze({ id: EW_STUDIO_SECTION, label: 'Entangled Worlds studio', app: 'entangled-worlds', part: 'Studio', actions: EW_STUDIO_SHORTCUTS }),
-  Object.freeze({ id: EW_PLAYER_SECTION, label: 'Entangled Worlds player', app: 'entangled-worlds', part: 'Player', actions: EW_PLAYER_SHORTCUTS }),
-])
-

package/src/shortcuts/site.ts

@@ -1,33 +0,0 @@
-// The Plantasia Space site's own keys: the pages around the apps (home, explore, settings). They
-// work on any page of the site, outside an Orbiter or a world.
-
-import type { ShortcutAction } from './match.js'
-
-export type SiteShortcut = ShortcutAction<'client'>
-
-export const SITE_SECTION = 'site'
-
-const site = (id: string, label: string, keys: string): SiteShortcut =>
-  Object.freeze({ id: `site.${id}`, section: SITE_SECTION, label, defaultKeys: Object.freeze([keys]), scope: 'client' as const })
-
-/**
- * Two-key sequences move around the site (G, then H for Home; N, then O for a new Orbiter), as on
- * many sites: a single letter is an Orbiter's on a page that plays one, and the browser holds most
- * ⌘ and ⇧⌘ letters.
- */
-export const SITE_SHORTCUTS: readonly SiteShortcut[] = Object.freeze([
-  site('settings', 'Open settings', 'Mod+Shift+Comma'),
-  site('commands', 'Commands', 'Mod+KeyK'),
-  site('search', 'Search', 'Slash'),
-  site('go.home', 'Home', 'KeyG KeyH'),
-  site('go.playground', 'Playground', 'KeyG KeyP'),
-  site('go.notifications', 'Notifications', 'KeyG KeyN'),
-  site('go.audios', 'My audios', 'KeyG KeyA'),
-  site('go.orbiters', 'My Orbiters', 'KeyG KeyO'),
-  site('go.worlds', 'My Entangled Worlds', 'KeyG KeyW'),
-  site('go.collections', 'My collections', 'KeyG KeyC'),
-  site('go.stars', 'My stars', 'KeyG KeyS'),
-  site('new.orbiter', 'New Orbiter', 'KeyN KeyO'),
-  site('new.audio', 'New audio', 'KeyN KeyA'),
-  site('new.world', 'New Entangled World', 'KeyN KeyW'),
-])