oneko 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,286 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { m as mountLaserCursor, s as startCatAnimation, g as getSkinSource, l as loadSkinSource, a as applyRuntimeConfig, b as createInitialCatState, O as ONEKO_DEFAULTS, r as readPersistedPosition, o as onCatsHiddenChange, d as areCatsHidden, T as TILE } from "./chunks/vanilla-CUrawvWx.js";
+import { e, c, i, f } from "./chunks/vanilla-CUrawvWx.js";
+function LaserCursor({ zIndex }) {
+  useEffect(() => mountLaserCursor(zIndex), [zIndex]);
+  return null;
+}
+function useCatAnimation({
+  enabled,
+  stateRef,
+  elRef,
+  lastStateRef,
+  onStateChangeRef,
+  liveStateRef,
+  persistPosition,
+  storageKey,
+  zIndex,
+  pettable
+}) {
+  useEffect(() => {
+    if (!enabled || typeof window === "undefined") {
+      return;
+    }
+    return startCatAnimation({
+      stateRef,
+      elRef,
+      lastStateRef,
+      onStateChangeRef,
+      liveStateRef,
+      persistPosition,
+      storageKey,
+      zIndex,
+      pettable
+    });
+  }, [
+    enabled,
+    stateRef,
+    elRef,
+    lastStateRef,
+    onStateChangeRef,
+    persistPosition,
+    storageKey,
+    zIndex,
+    pettable,
+    liveStateRef
+  ]);
+}
+function useSpriteAppearance(elRef, source, hueRotate = 0) {
+  const previous = useRef(null);
+  const transition = useRef(null);
+  useEffect(() => {
+    const el = elRef.current;
+    if (!el || !source) return;
+    const filter = hueRotate ? `hue-rotate(${hueRotate}deg)` : "blur(0px)";
+    const last = previous.current;
+    if (last?.el === el && last.source === source && last.filter === filter) return;
+    transition.current?.cancel();
+    transition.current = null;
+    el.style.backgroundImage = `url(${JSON.stringify(source)})`;
+    el.style.filter = filter;
+    previous.current = { el, source, filter };
+    if (last?.el === el && last.source !== source && !window.matchMedia("(prefers-reduced-motion: reduce)").matches && typeof el.animate === "function") {
+      transition.current = el.animate(
+        [{ filter: `${filter} blur(2px)` }, { filter: `${filter} blur(0px)` }],
+        { duration: 220, easing: "ease-out" }
+      );
+    }
+  });
+  useEffect(() => () => transition.current?.cancel(), []);
+}
+function useSkinSource(skin, spriteSrc) {
+  const ready = spriteSrc || getSkinSource(skin);
+  const [, setLoadedSkin] = useState();
+  useEffect(() => {
+    if (ready) return;
+    let current = true;
+    loadSkinSource(skin).then(
+      () => current && setLoadedSkin(skin),
+      () => {
+      }
+    );
+    return () => {
+      current = false;
+    };
+  }, [ready, skin]);
+  return ready;
+}
+function useOnekoPropsSync(stateRef, elRef, props) {
+  useSpriteAppearance(elRef, useSkinSource(props.skin, props.spriteSrc), props.hueRotate);
+  useEffect(() => {
+    const state = stateRef.current;
+    applyRuntimeConfig(state, props);
+    const el = elRef.current;
+    if (!el) return;
+    el.style.transform = `scale(${props.scale}) rotate(${state.currentRotation}deg)`;
+    el.style.opacity = String(props.opacity);
+  });
+}
+const REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
+function subscribe(onChange) {
+  const query = window.matchMedia?.(REDUCED_MOTION_QUERY);
+  query?.addEventListener("change", onChange);
+  return () => query?.removeEventListener("change", onChange);
+}
+function getSnapshot() {
+  return !(window.matchMedia?.(REDUCED_MOTION_QUERY).matches ?? false);
+}
+function useMotionAllowed() {
+  return useSyncExternalStore(subscribe, getSnapshot, () => false);
+}
+function useReducedMotion() {
+  return !useSyncExternalStore(subscribe, getSnapshot, () => true);
+}
+function useCatsHidden() {
+  return useSyncExternalStore(onCatsHiddenChange, areCatsHidden, () => false);
+}
+function Oneko({
+  paused = ONEKO_DEFAULTS.paused,
+  followCursor = ONEKO_DEFAULTS.followCursor,
+  sleepEnabled = ONEKO_DEFAULTS.sleepEnabled,
+  bubblePlacement = ONEKO_DEFAULTS.bubblePlacement,
+  bubbleScale = ONEKO_DEFAULTS.bubbleScale,
+  soundBasePath = ONEKO_DEFAULTS.soundBasePath,
+  storageKey = ONEKO_DEFAULTS.storageKey,
+  zones,
+  zoneAttractionChance = ONEKO_DEFAULTS.zoneAttractionChance,
+  zoneAttractionDuration = ONEKO_DEFAULTS.zoneAttractionDuration,
+  skin = ONEKO_DEFAULTS.skin,
+  spriteSrc,
+  persistPosition = ONEKO_DEFAULTS.persistPosition,
+  /** One below max so fixed UI can sit above the cat. */
+  zIndex = ONEKO_DEFAULTS.zIndex,
+  initialPos,
+  speed = ONEKO_DEFAULTS.speed,
+  scale = ONEKO_DEFAULTS.scale,
+  opacity = ONEKO_DEFAULTS.opacity,
+  rotationAmount = ONEKO_DEFAULTS.rotationAmount,
+  idleThreshold = ONEKO_DEFAULTS.idleThreshold,
+  meow = ONEKO_DEFAULTS.meow,
+  onStateChange,
+  freerunChance = ONEKO_DEFAULTS.freerunChance,
+  freerunDuration = ONEKO_DEFAULTS.freerunDuration,
+  bubbleEnabled = ONEKO_DEFAULTS.bubbleEnabled,
+  bubbleDisplayFrames = ONEKO_DEFAULTS.bubbleDisplayFrames,
+  bubbleCooldown = ONEKO_DEFAULTS.bubbleCooldown,
+  hueRotate = ONEKO_DEFAULTS.hueRotate,
+  liveStateRef,
+  bubbleChance = ONEKO_DEFAULTS.bubbleChance,
+  followDistance = ONEKO_DEFAULTS.followDistance,
+  animationSpeed = ONEKO_DEFAULTS.animationSpeed,
+  bubbleText = ONEKO_DEFAULTS.bubbleText,
+  volume = ONEKO_DEFAULTS.volume,
+  laserPointer = ONEKO_DEFAULTS.laserPointer,
+  reducedMotion = ONEKO_DEFAULTS.reducedMotion,
+  chase = ONEKO_DEFAULTS.chase,
+  napWhileTyping = ONEKO_DEFAULTS.napWhileTyping,
+  followFocus = ONEKO_DEFAULTS.followFocus,
+  perchOnHover = ONEKO_DEFAULTS.perchOnHover,
+  pettable = ONEKO_DEFAULTS.pettable
+}) {
+  const hidden = useCatsHidden();
+  const motionAllowed = useMotionAllowed() && !hidden;
+  const prefersReducedMotion = useReducedMotion();
+  const restingSource = useSkinSource(skin, spriteSrc);
+  const elRef = useRef(null);
+  const lastStateRef = useRef("idle");
+  const onStateChangeRef = useRef(onStateChange);
+  useEffect(() => {
+    onStateChangeRef.current = onStateChange;
+  }, [onStateChange]);
+  const config = {
+    paused,
+    followCursor,
+    sleepEnabled,
+    bubblePlacement,
+    bubbleScale,
+    soundBasePath,
+    zones,
+    zoneAttractionChance,
+    zoneAttractionDuration,
+    speed,
+    scale,
+    opacity,
+    rotationAmount,
+    idleThreshold,
+    freerunChance,
+    freerunDuration,
+    bubbleEnabled,
+    bubbleDisplayFrames,
+    bubbleCooldown,
+    bubbleChance,
+    followDistance,
+    animationSpeed,
+    bubbleText,
+    meow,
+    volume,
+    laserPointer: laserPointer && followCursor && !paused,
+    chase,
+    napWhileTyping,
+    followFocus,
+    perchOnHover
+  };
+  const [initialState] = useState(() => createInitialCatState({ initialPos, ...config }));
+  const stateRef = useRef(initialState);
+  useCatAnimation({
+    enabled: motionAllowed,
+    stateRef,
+    elRef,
+    lastStateRef,
+    onStateChangeRef,
+    liveStateRef,
+    persistPosition,
+    storageKey,
+    zIndex,
+    pettable
+  });
+  useOnekoPropsSync(stateRef, elRef, {
+    ...config,
+    hueRotate,
+    skin,
+    spriteSrc
+  });
+  if (!hidden && prefersReducedMotion && reducedMotion === "rest" && restingSource) {
+    return /* @__PURE__ */ jsx(
+      RestingCat,
+      {
+        source: restingSource,
+        position: persistPosition && readPersistedPosition(storageKey) || initialPos,
+        scale,
+        opacity,
+        hueRotate,
+        zIndex
+      }
+    );
+  }
+  return motionAllowed && config.laserPointer ? /* @__PURE__ */ jsx(LaserCursor, { zIndex }) : null;
+}
+function RestingCat({
+  source,
+  position,
+  scale,
+  opacity,
+  hueRotate,
+  zIndex
+}) {
+  const inset = TILE * scale / 2 + 16;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "aria-hidden": "true",
+      style: {
+        position: "fixed",
+        left: position ? position.x - TILE / 2 : void 0,
+        top: position ? position.y - TILE / 2 : void 0,
+        right: position ? void 0 : inset - TILE / 2,
+        bottom: position ? void 0 : inset - TILE / 2,
+        width: TILE,
+        height: TILE,
+        pointerEvents: "none",
+        imageRendering: "pixelated",
+        backgroundImage: `url(${JSON.stringify(source)})`,
+        backgroundRepeat: "no-repeat",
+        backgroundSize: "256px 128px",
+        // Sleeping frame, matching defaultSpriteSets.sleeping[0].
+        backgroundPosition: `-${2 * TILE}px 0`,
+        transform: `scale(${scale})`,
+        opacity,
+        filter: hueRotate ? `hue-rotate(${hueRotate}deg)` : void 0,
+        zIndex
+      }
+    }
+  );
+}
+export {
+  e as ONEKO_SKINS,
+  Oneko,
+  areCatsHidden,
+  c as createOneko,
+  Oneko as default,
+  i as isOnekoSkin,
+  onCatsHiddenChange,
+  f as setCatsHidden,
+  useCatsHidden
+};

package/dist/solid.js

@@ -0,0 +1,17 @@
+import { onMount, onCleanup, createEffect } from "solid-js";
+import { c as createOneko } from "./chunks/vanilla-CUrawvWx.js";
+import { createPropsUpdater } from "./adapter.js";
+function Oneko(props) {
+  let update;
+  onMount(() => {
+    const cat = createOneko();
+    update = createPropsUpdater(cat);
+    update({ ...props });
+    onCleanup(() => cat.destroy());
+  });
+  createEffect(() => update?.({ ...props }));
+  return null;
+}
+export {
+  Oneko as default
+};

package/dist/svelte/Oneko.svelte

@@ -0,0 +1,17 @@
+<script lang="ts">
+  import { onMount } from "svelte";
+  import { createOneko, type OnekoOptions } from "../vanilla.js";
+  import { createPropsUpdater } from "../adapter.js";
+
+  const props: OnekoOptions = $props();
+  let update = $state.raw<ReturnType<typeof createPropsUpdater>>();
+
+  onMount(() => {
+    const cat = createOneko();
+    update = createPropsUpdater(cat);
+    update({ ...props });
+    return () => cat.destroy();
+  });
+
+  $effect(() => update?.({ ...props }));
+</script>

package/dist/svelte/Oneko.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { Component } from "svelte";
+import type { OnekoOptions } from "../types/packages/oneko/src/vanilla";
+declare const Oneko: Component<OnekoOptions>;
+export default Oneko;

package/dist/types/components/laser-cursor.d.ts

@@ -0,0 +1,3 @@
+export declare function LaserCursor({ zIndex }: {
+    zIndex: number;
+}): null;

package/dist/types/components/oneko.d.ts

@@ -0,0 +1,11 @@
+import { setCatsHidden } from "../lib/oneko/pack";
+import type { CatActivityState, CatLiveState, OnekoProps } from "../lib/oneko/types";
+export type { CatActivityState, CatLiveState, OnekoProps };
+export type { OnekoSkin } from "../lib/oneko/skins";
+export type { OnekoZone } from "../lib/oneko/zones";
+export { setCatsHidden };
+/** The visitor's remembered choice to hide every cat on the site. Pair with setCatsHidden. */
+export declare function useCatsHidden(): boolean;
+export default function Oneko({ paused, followCursor, sleepEnabled, bubblePlacement, bubbleScale, soundBasePath, storageKey, zones, zoneAttractionChance, zoneAttractionDuration, skin, spriteSrc, persistPosition, 
+/** One below max so fixed UI can sit above the cat. */
+zIndex, initialPos, speed, scale, opacity, rotationAmount, idleThreshold, meow, onStateChange, freerunChance, freerunDuration, bubbleEnabled, bubbleDisplayFrames, bubbleCooldown, hueRotate, liveStateRef, bubbleChance, followDistance, animationSpeed, bubbleText, volume, laserPointer, reducedMotion, chase, napWhileTyping, followFocus, perchOnHover, pettable, }: OnekoProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/types/hooks/use-cat-animation.d.ts

@@ -0,0 +1,23 @@
+import type { CatActivityState, CatLiveState, CatRuntimeState } from "../lib/oneko/types";
+export declare function useCatAnimation({ enabled, stateRef, elRef, lastStateRef, onStateChangeRef, liveStateRef, persistPosition, storageKey, zIndex, pettable, }: {
+    enabled: boolean;
+    stateRef: {
+        current: CatRuntimeState;
+    };
+    elRef: {
+        current: HTMLDivElement | null;
+    };
+    lastStateRef: {
+        current: CatActivityState;
+    };
+    onStateChangeRef: {
+        current: ((state: CatActivityState) => void) | undefined;
+    };
+    liveStateRef?: {
+        current: CatLiveState;
+    };
+    persistPosition: boolean;
+    storageKey: string;
+    zIndex: number;
+    pettable: boolean;
+}): void;

package/dist/types/hooks/use-motion-allowed.d.ts

@@ -0,0 +1,3 @@
+export declare function useMotionAllowed(): boolean;
+/** True only on the client when the visitor asks for reduced motion. */
+export declare function useReducedMotion(): boolean;

package/dist/types/hooks/use-oneko-props-sync.d.ts

@@ -0,0 +1,14 @@
+import { type CatRuntimeConfig } from "../lib/oneko/runtime-config";
+import type { OnekoSkin } from "../lib/oneko/skins";
+import type { CatRuntimeState } from "../lib/oneko/types";
+type SyncableProps = CatRuntimeConfig & {
+    hueRotate: number;
+    skin: OnekoSkin;
+    spriteSrc?: string;
+};
+export declare function useOnekoPropsSync(stateRef: {
+    current: CatRuntimeState;
+}, elRef: {
+    current: HTMLDivElement | null;
+}, props: SyncableProps): void;
+export {};

package/dist/types/hooks/use-skin-source.d.ts

@@ -0,0 +1,3 @@
+import { type OnekoSkin } from "../lib/oneko/skins";
+/** Sprite sheet to draw: a custom sprite, a ready skin, or undefined while a skin loads. */
+export declare function useSkinSource(skin: OnekoSkin, spriteSrc?: string): string | undefined;

package/dist/types/hooks/use-sprite-appearance.d.ts

@@ -0,0 +1,6 @@
+/** Soften sprite changes without affecting movement, scale, or the selected tint. */
+export declare function useSpriteAppearance(elRef: {
+    current: HTMLElement | null;
+}, 
+/** Undefined while a skin loads; the current sheet stays until the next one is ready. */
+source: string | undefined, hueRotate?: number): void;

package/dist/types/lib/oneko/animation/activity.d.ts

@@ -0,0 +1,5 @@
+import type { CatActivityState, CatRuntimeState } from "../types";
+import type { CatAnimationDeps } from "./deps";
+export declare function getActivityLabel(deps: CatAnimationDeps): CatActivityState;
+export declare function getBubbleStatus(s: CatRuntimeState): string;
+export declare function playSound(deps: CatAnimationDeps, pool: string[]): void;

package/dist/types/lib/oneko/animation/attention.d.ts

@@ -0,0 +1,13 @@
+import type { CatRuntimeState } from "../types";
+import type { CatAnimationDeps } from "./deps";
+/** How close the cat gets before it settles, depending on what it is after. */
+export declare function stopDistance(s: CatRuntimeState): number;
+/** Per-frame upkeep for page reactions; runs before the movement target is chosen. */
+export declare function tickAttention(deps: CatAnimationDeps): void;
+/**
+ * Listens to the page for typing, keyboard focus, and resting pointers. Options are read from
+ * the runtime state on every event, so toggling them needs no restart.
+ */
+export declare function watchPage(deps: CatAnimationDeps): () => void;
+/** Turns the cat into a focusable "Pet the cat" button. It holds still while focused. */
+export declare function makePettable(deps: CatAnimationDeps): () => void;

package/dist/types/lib/oneko/animation/bubbles.d.ts

@@ -0,0 +1,5 @@
+import type { CatAnimationDeps } from "./deps";
+export declare function pickFromPool(deps: CatAnimationDeps, pool: readonly string[]): string;
+export declare function showBubble(deps: CatAnimationDeps): void;
+export declare function hideBubble(deps: CatAnimationDeps): void;
+export declare function updateBubble(deps: CatAnimationDeps): void;

package/dist/types/lib/oneko/animation/debug-render.d.ts

@@ -0,0 +1,5 @@
+import type { CatAnimationDeps } from "./deps";
+export declare function createDebugRenderer(deps: CatAnimationDeps): {
+    renderDebug: () => void;
+    maybeRenderDebug: () => void;
+};

package/dist/types/lib/oneko/animation/deps.d.ts

@@ -0,0 +1,21 @@
+import type { CatActivityState, CatLiveState, CatRuntimeState } from "../types";
+export interface CatAnimationDeps {
+    stateRef: {
+        current: CatRuntimeState;
+    };
+    el: HTMLDivElement;
+    bubbleEl: HTMLDivElement;
+    bubbleTextEl: HTMLDivElement;
+    bubbleTail: HTMLDivElement;
+    debugSVG: SVGSVGElement;
+    debugHUD: HTMLDivElement;
+    lastStateRef: {
+        current: CatActivityState;
+    };
+    onStateChangeRef: {
+        current: ((state: CatActivityState) => void) | undefined;
+    };
+    liveStateRef?: {
+        current: CatLiveState;
+    };
+}

package/dist/types/lib/oneko/animation/frame/interrupt-idle.d.ts

@@ -0,0 +1,2 @@
+import type { CatRuntimeState } from "../../types";
+export declare function interruptIdleIfChasing(s: CatRuntimeState, dist: number): void;

package/dist/types/lib/oneko/animation/frame/tick-laser.d.ts

@@ -0,0 +1,2 @@
+import type { CatAnimationDeps } from "../deps";
+export declare function tickLaser(deps: CatAnimationDeps, dist: number): void;

package/dist/types/lib/oneko/animation/frame/tick-live-state.d.ts

@@ -0,0 +1,3 @@
+import type { CatActivityState } from "../../types";
+import type { CatAnimationDeps } from "../deps";
+export declare function tickLiveState(deps: CatAnimationDeps, dist: number, currentState: CatActivityState): void;

package/dist/types/lib/oneko/animation/frame/tick-movement.d.ts

@@ -0,0 +1,2 @@
+import type { CatAnimationDeps } from "../deps";
+export declare function tickMovement(deps: CatAnimationDeps, dist: number): void;

package/dist/types/lib/oneko/animation/frame/tick-prelude.d.ts

@@ -0,0 +1,2 @@
+import type { CatRuntimeState } from "../../types";
+export declare function tickPrelude(s: CatRuntimeState): void;

package/dist/types/lib/oneko/animation/frame/tick-sounds.d.ts

@@ -0,0 +1,3 @@
+import type { CatActivityState } from "../../types";
+import type { CatAnimationDeps } from "../deps";
+export declare function tickSounds(deps: CatAnimationDeps): CatActivityState;

package/dist/types/lib/oneko/animation/frame.d.ts

@@ -0,0 +1,2 @@
+import type { CatAnimationDeps } from "./deps";
+export declare function createFrameLoop(deps: CatAnimationDeps): () => void;

package/dist/types/lib/oneko/animation/grid.d.ts

@@ -0,0 +1,3 @@
+import type { CatAnimationDeps } from "./deps";
+export declare function refreshGridIfNeeded(deps: CatAnimationDeps): void;
+export declare function recalcPathIfNeeded(deps: CatAnimationDeps): void;

package/dist/types/lib/oneko/animation/idle.d.ts

@@ -0,0 +1,4 @@
+import type { CatAnimationDeps } from "./deps";
+export declare function maybeStartIdleAnimation(deps: CatAnimationDeps): void;
+export declare function updateIdleAnimation(deps: CatAnimationDeps): boolean;
+export declare function freezeLockedState(deps: CatAnimationDeps): boolean;

package/dist/types/lib/oneko/animation/mouse.d.ts

@@ -0,0 +1,2 @@
+import type { CatAnimationDeps } from "./deps";
+export declare function createMouseMoveHandler(deps: CatAnimationDeps): (ev: MouseEvent) => void;

package/dist/types/lib/oneko/animation/movement.d.ts

@@ -0,0 +1,3 @@
+import type { CatAnimationDeps } from "./deps";
+export declare function recalculatePath(deps: CatAnimationDeps): void;
+export declare function followPath(deps: CatAnimationDeps, overallDist: number): void;

package/dist/types/lib/oneko/animation/sprites.d.ts

@@ -0,0 +1,5 @@
+import { defaultSpriteSets } from "../constants";
+import type { CatAnimationDeps } from "./deps";
+export declare function setSprite(deps: CatAnimationDeps, name: keyof typeof defaultSpriteSets | string, frame: number): void;
+export declare function directionFromDelta(dx: number, dy: number): string | null;
+export declare function clearRotation(deps: CatAnimationDeps): void;

package/dist/types/lib/oneko/animation-loop.d.ts

@@ -0,0 +1,5 @@
+import type { CatRuntimeState } from "./types";
+/** The sprite has ten frames per second; no need to wake on every screen refresh. */
+export declare function startAnimationLoop(stateRef: {
+    current: CatRuntimeState;
+}, frame: () => void): () => void;

package/dist/types/lib/oneko/constants.d.ts

@@ -0,0 +1,118 @@
+import type { CatActivityState } from "./types";
+export declare const TILE = 32;
+export declare const DEFAULT_Z_INDEX = 2147483646;
+export declare const STEER_LERP = 0.3;
+export declare const MAX_VEL_FACTOR = 1.5;
+export declare const OBSTACLE_INTERVAL = 30;
+export declare const MIN_OBSTACLE_AREA = 500;
+export declare const OBSTACLE_SELECTOR = "h1,h2,h3,h4,h5,h6,p,blockquote,a,button,img,svg,picture,video,nav,header,label,[role='button'],[data-oneko-obstacle]";
+export declare const CELL_SIZE = 16;
+export declare const SPRITE_RADIUS = 8;
+export declare const PATH_RECALC_INTERVAL = 10;
+export declare const PATH_RECALC_MOUSE_CELLS = 2;
+export declare const WAYPOINT_REACH_DIST = 16;
+export declare const BUBBLE_DISPLAY_FRAMES = 180;
+export declare const BUBBLE_COOLDOWN_FRAMES = 120;
+/** Pixels between mouse samples before we treat movement as a new heading */
+export declare const MOUSE_LOOP_MIN_STEP = 5;
+/** Total radians of cursor-heading spin to count as “going in circles” */
+export declare const MOUSE_LOOP_WINDING_TRIGGER = 6.2;
+/** Soft cap so winding doesn’t run away (about two full spins) */
+export declare const MOUSE_LOOP_WINDING_CAP = 13;
+/** Per logic frame decay so old spinning fades out */
+export declare const MOUSE_LOOP_WINDING_DECAY = 0.96;
+export declare const IDLE_MESSAGES: string[];
+export declare const MOVING_MESSAGES: string[];
+export declare const CIRCLE_LOOP_MESSAGES: string[];
+export declare const SLEEPING_MESSAGES: string[];
+export declare const SCRATCHING_MESSAGES: string[];
+export declare const TIRED_MESSAGES: string[];
+export declare const WALL_SCRATCH_MESSAGES: string[];
+export declare const ALERT_MESSAGES: string[];
+export declare const FREERUN_MESSAGES: string[];
+export declare const FREERUN_CHANCE = 0.06;
+export declare const FREERUN_DURATION = 40;
+export declare const DEFAULT_SPEED = 10;
+export declare const DEFAULT_SCALE = 1;
+export declare const DEFAULT_OPACITY = 1;
+export declare const DEFAULT_ROTATION_AMOUNT = 15;
+export declare const DEFAULT_IDLE_THRESHOLD_MS = 1000;
+export declare const DEFAULT_VOLUME = 0.5;
+export declare const DEFAULT_BUBBLE_CHANCE = 0.5;
+export declare const DEFAULT_FOLLOW_DISTANCE = 20;
+export declare const DEFAULT_ANIMATION_SPEED = 1;
+export declare const PET_MESSAGES: string[];
+export declare const PET_SOUND_POOL: string[];
+export declare const LASER_CATCH_POOL: string[];
+export declare const SOUND_POOLS: Record<CatActivityState, string[]>;
+export declare const KONAMI_SEQUENCE: string[];
+export declare const KONAMI_TARGET: string;
+export declare const DIRECTION_RANGES: readonly [{
+    readonly min: -22.5;
+    readonly max: 22.5;
+    readonly dir: "E";
+}, {
+    readonly min: 22.5;
+    readonly max: 67.5;
+    readonly dir: "SE";
+}, {
+    readonly min: 67.5;
+    readonly max: 112.5;
+    readonly dir: "S";
+}, {
+    readonly min: 112.5;
+    readonly max: 157.5;
+    readonly dir: "SW";
+}, {
+    readonly min: -157.5;
+    readonly max: -112.5;
+    readonly dir: "NW";
+}, {
+    readonly min: -112.5;
+    readonly max: -67.5;
+    readonly dir: "N";
+}, {
+    readonly min: -67.5;
+    readonly max: -22.5;
+    readonly dir: "NE";
+}];
+export declare const NEIGHBOR_OFFSETS: [number, number, number][];
+export declare const defaultSpriteSets: {
+    readonly idle: readonly [readonly [-3, -3]];
+    readonly alert: readonly [readonly [-7, -3]];
+    readonly scratchSelf: readonly [readonly [-5, 0], readonly [-6, 0], readonly [-7, 0]];
+    readonly scratchWallN: readonly [readonly [0, 0], readonly [0, -1]];
+    readonly scratchWallS: readonly [readonly [-7, -1], readonly [-6, -2]];
+    readonly scratchWallE: readonly [readonly [-2, -2], readonly [-2, -3]];
+    readonly scratchWallW: readonly [readonly [-4, 0], readonly [-4, -1]];
+    readonly tired: readonly [readonly [-3, -2]];
+    readonly sleeping: readonly [readonly [-2, 0], readonly [-2, -1]];
+    readonly N: readonly [readonly [-1, -2], readonly [-1, -3]];
+    readonly NE: readonly [readonly [0, -2], readonly [0, -3]];
+    readonly E: readonly [readonly [-3, 0], readonly [-3, -1]];
+    readonly SE: readonly [readonly [-5, -1], readonly [-5, -2]];
+    readonly S: readonly [readonly [-6, -3], readonly [-7, -2]];
+    readonly SW: readonly [readonly [-5, -3], readonly [-6, -1]];
+    readonly W: readonly [readonly [-4, -2], readonly [-4, -3]];
+    readonly NW: readonly [readonly [-1, 0], readonly [-1, -1]];
+};
+export declare const IDLE_ANIMATION_DURATIONS: Record<string, number>;
+export declare const debugColor: {
+    panelBg: string;
+    panelBorder: string;
+    panelText: string;
+    panelSubtle: string;
+    controlBg: string;
+    controlBorder: string;
+    accent: string;
+    accentStrong: string;
+    danger: string;
+    dangerSoft: string;
+    trail: string;
+    trailDot: string;
+    gridStroke: string;
+};
+export declare const DEFAULT_POSITION: {
+    x: number;
+    y: number;
+};

package/dist/types/lib/oneko/debug-controls/bubble.d.ts

@@ -0,0 +1,4 @@
+import type { CatRuntimeState } from "../types";
+export declare function appendBubbleSection(body: HTMLElement, stateRef: {
+    current: CatRuntimeState;
+}, bubbleEl: HTMLDivElement, bubbleTextEl: HTMLDivElement, showBubble: () => void, hideBubble: () => void, bubbleDisplayFrames: number): void;

package/dist/types/lib/oneko/debug-controls/force-state.d.ts

@@ -0,0 +1,4 @@
+import type { CatRuntimeState } from "../types";
+export declare function appendForceStateSection(body: HTMLElement, stateRef: {
+    current: CatRuntimeState;
+}): void;