Made of little things.

/** Native browser input. No NAP domain, host messages, network or storage required. */
export type GamepadBinding = { button: number; scale?: 1 | -1 } | { axis: number; scale?: 1 | -1 };
export type GamepadBindings = Record<string, readonly GamepadBinding[]>;
export type GamepadAction = { value: number; down: boolean; pressed: boolean; released: boolean };
export type Controller = {
  index: number;
  id: string;
  mapping: string;
  mapped: boolean;
  axes: number[];
  buttons: number[];
  actions: Record<string, GamepadAction>;
};
export type ControllerFrame = {
  status: 'ready' | 'waiting' | 'inactive' | 'unavailable' | 'blocked' | 'closed';
  players: Controller[];
  connected: number[];
  disconnected: number[];
};
export type GamepadSample = Pick<
  Gamepad,
  'index' | 'id' | 'mapping' | 'connected' | 'axes' | 'buttons'
>;

/** Standard layout positions, not vendor-specific button lettering. Adapt action names to the game. */
export const standardGamepadBindings: GamepadBindings = {
  moveX: [{ axis: 0 }, { button: 14, scale: -1 }, { button: 15 }],
  moveY: [{ axis: 1 }, { button: 12, scale: -1 }, { button: 13 }],
  aimX: [{ axis: 2 }],
  aimY: [{ axis: 3 }],
  jump: [{ button: 0 }],
  fire: [{ button: 7 }],
  pause: [{ button: 9 }],
};

function checkedBindings(bindings: GamepadBindings): GamepadBindings {
  const copy: GamepadBindings = Object.create(null);
  for (const [name, sources] of Object.entries(bindings)) {
    copy[name] = sources.map((source) => {
      const index = 'button' in source ? source.button : source.axis;
      if (
        !Number.isInteger(index) ||
        index < 0 ||
        (source.scale !== undefined && ![1, -1].includes(source.scale))
      )
        throw new Error(
          'Controller bindings need nonnegative integer indices and a scale of 1 or -1.',
        );
      return { ...source };
    });
  }
  return copy;
}
const finite = (value: number, min = -1) =>
  Number.isFinite(value) ? Math.max(min, Math.min(1, value)) : 0;

/** Poll once per game animation frame. Keep one instance per running napplet; dispose on teardown. */
export function createGamepadInput(
  bindings: GamepadBindings = standardGamepadBindings,
  options: {
    deadZone?: number;
    buttonThreshold?: number;
    /** Dependency injection for deterministic game tests; defaults to the native browser API. */
    read?: () => ArrayLike<GamepadSample | null>;
    active?: () => boolean;
  } = {},
) {
  const defaults = checkedBindings(bindings);
  const deadZone = options.deadZone ?? 0.18,
    threshold = options.buttonThreshold ?? 0.5;
  if (
    !Number.isFinite(deadZone) ||
    deadZone < 0 ||
    deadZone >= 1 ||
    !Number.isFinite(threshold) ||
    threshold <= 0 ||
    threshold > 1
  )
    throw new Error(
      'Use a dead zone from 0 up to (excluding) 1 and a button threshold above 0 through 1.',
    );
  let previous = new Map<number, Controller>(),
    activeLast = false,
    closed = false;
  const overrides = new Map<number, { id: string; bindings: GamepadBindings }>();
  const reset = () => {
    activeLast = false;
  };
  const browserWindow = typeof window !== 'undefined' ? window : undefined;
  browserWindow?.addEventListener('blur', reset);
  browserWindow?.document.addEventListener('visibilitychange', reset);
  const active =
    options.active ??
    (() => !!browserWindow && !browserWindow.document.hidden && browserWindow.document.hasFocus());
  const read =
    options.read ??
    (() => {
      if (typeof navigator === 'undefined' || !navigator.getGamepads)
        throw new Error('Gamepad API unavailable');
      return navigator.getGamepads();
    });
  function empty(status: ControllerFrame['status']): ControllerFrame {
    const disconnected = [...previous.keys()];
    previous.clear();
    overrides.clear();
    activeLast = false;
    return { status, players: [], connected: [], disconnected };
  }
  return {
    poll(): ControllerFrame {
      if (closed) return empty('closed');
      let samples: GamepadSample[];
      try {
        samples = Array.from(read()).filter((pad): pad is GamepadSample => !!pad?.connected);
      } catch (error) {
        return empty(
          error instanceof Error && error.name === 'SecurityError' ? 'blocked' : 'unavailable',
        );
      }
      const enabled = active(),
        next = new Map<number, Controller>();
      const connected: number[] = [],
        disconnected: number[] = [];
      for (const pad of samples) {
        const old = previous.get(pad.index),
          same = old?.id === pad.id && old.mapping === pad.mapping;
        if (!same) {
          connected.push(pad.index);
          overrides.delete(pad.index);
        }
        const override = overrides.get(pad.index);
        const mapped = pad.mapping === 'standard' || override?.id === pad.id;
        const layout = override?.bindings ?? defaults;
        const axes = pad.axes.map((v) => (enabled ? finite(v) : 0));
        const buttons = pad.buttons.map((b) => (enabled ? finite(b.value, 0) : 0));
        const actions: Record<string, GamepadAction> = Object.create(null);
        for (const [name, sources] of Object.entries(layout)) {
          let positive = 0,
            negative = 0;
          if (enabled && mapped)
            for (const source of sources) {
              let input =
                'button' in source ? (buttons[source.button] ?? 0) : (axes[source.axis] ?? 0);
              if ('axis' in source)
                input =
                  Math.sign(input) * Math.max(0, (Math.abs(input) - deadZone) / (1 - deadZone));
              input *= source.scale ?? 1;
              positive = Math.max(positive, input);
              negative = Math.min(negative, input);
            }
          const value = positive === -negative ? 0 : positive > -negative ? positive : negative;
          const down = Math.abs(value) >= threshold,
            wasDown = same && !!old.actions[name]?.down;
          actions[name] = {
            value,
            down,
            pressed: enabled && activeLast && same && down && !wasDown,
            released: wasDown && !down,
          };
        }
        next.set(pad.index, {
          index: pad.index,
          id: pad.id,
          mapping: pad.mapping,
          mapped,
          axes,
          buttons,
          actions,
        });
      }
      for (const [index, old] of previous) {
        const current = next.get(index);
        if (!current || current.id !== old.id || current.mapping !== old.mapping) {
          disconnected.push(index);
          if (!current) overrides.delete(index);
        }
      }
      previous = next;
      activeLast = enabled;
      // Return detached snapshots: a game's mutations cannot corrupt later button edges.
      return {
        status: enabled ? (next.size ? 'ready' : 'waiting') : 'inactive',
        players: structuredClone([...next.values()]),
        connected,
        disconnected,
      };
    },
    /** Explicit mapping for this connected slot. Forgotten on disconnect/replacement; never guessed by vendor ID. */
    remap(index: number, layout: GamepadBindings) {
      const pad = previous.get(index);
      if (!pad || closed) throw new Error('Connect and poll this controller before mapping it.');
      overrides.set(index, { id: pad.id, bindings: checkedBindings(layout) });
      activeLast = false;
    },
    reset,
    dispose() {
      closed = true;
      empty('closed');
      browserWindow?.removeEventListener('blur', reset);
      browserWindow?.document.removeEventListener('visibilitychange', reset);
    },
  };
}