@softov/ahpc 0.1.0

package/dist/src/view/bood/render.js

@@ -0,0 +1,196 @@
+import { jsx as _jsx } from "@textui/core/jsx-runtime";
+import { defineComponent, useFrame, useMeasure, useMemo, useRef, useState } from '@textui/core';
+import { Column } from '@textui/widgets';
+import { anchorOf, blit, fill, metric } from './art.js';
+import { carry, createBody, faceOf, frameOf, grab, poseOf, release, slipped, stepBody, WORLD, } from './motion.js';
+import { creatureFrames, creatureMotion, creatureNames, poseFrames } from './registry.js';
+/**
+ * A mood per tone, rather than a colour per creature.
+ *
+ * Which creature you got says nothing; what it is doing is the thing worth
+ * reading from across the room. Semantic names, so a theme decides the colour
+ * and the figure is legible on paper as well as on a dark terminal.
+ *
+ * The two that also appear in the session list borrow that list's tones on
+ * purpose: `executing` is accent because that is what a running session is,
+ * and `error` is danger because that is what a failed one is. A mascot that
+ * disagreed with the status column about what red means would be worse than
+ * no mascot.
+ */
+const TONE = {
+    happy: 'success',
+    sad: 'muted',
+    thinking: 'info',
+    executing: 'accent',
+    error: 'danger',
+};
+/**
+ * How fast the cycle turns.
+ *
+ * One rate for every form and every mood, with the holds written into the art
+ * instead - `blink` and `alternate` in `art.ts`. A component that chose its own
+ * rate per mood would put the timing in two places, and the drawing would lose.
+ */
+const FPS = 2;
+/**
+ * The second clock, for the half that moves.
+ *
+ * Twelve rather than two, because a body under gravity at two frames a second
+ * is a body teleporting; and twelve rather than thirty, because every tick is
+ * a repaint of the whole subtree and a mascot is not what the frame budget is
+ * for. Position is a float and rendering rounds, so what twelve costs is the
+ * top speed - past about a cell a tick the figure starts to skip.
+ */
+const MOTION_FPS = 12;
+/** How much of a stall it will catch up on, rather than leaping across the box. */
+const MAX_CATCHUP = 4;
+const clamp = (value, low, high) => (value < low ? low : value > high ? high : value);
+export const Creature = defineComponent('Creature', (props) => {
+    const { name, mood = 'happy', form = 'draw', animated = true, tone, lively = false, fieldWidth = 48, fieldHeight = 10, ...rest } = props;
+    // Picked once and kept: a figure that changed on every keystroke would be
+    // a flicker rather than a mascot. `useMemo` with no deps is the mount.
+    const names = creatureNames();
+    const chosen = useMemo(() => name ?? names[Math.floor(Math.random() * names.length)], [name]);
+    // Unconditional, because it is a hook. What `animated` decides is whether
+    // the number is used, not whether the ticker exists - and a ticker that
+    // appeared and vanished with a prop would be a hook order bug the first
+    // time a mood turned animation off.
+    const frame = useFrame(FPS);
+    // Also unconditional, and also gated: a ticker is a standing invalidation,
+    // so the one that runs at twelve a second has to be off for every figure
+    // that is not moving rather than merely ignored.
+    const motion = creatureMotion(chosen);
+    const running = lively && motion !== undefined && animated;
+    const beat = useFrame(MOTION_FPS, { enabled: running });
+    const body = useRef(createBody());
+    const seen = useRef(0);
+    const placed = useRef(false);
+    // Where the field is on the terminal, so an absolute pointer can be asked
+    // which cell of the field it is over.
+    const rect = useMeasure();
+    const drag = useRef(null);
+    /**
+     * What tells the runtime the body moved.
+     *
+     * The body lives in a ref, because physics wants somewhere to accumulate
+     * that is not a render. The cost is that mutating it is invisible: a
+     * pointer that carries the creature across the screen changes nothing the
+     * runtime can see, so the component is never marked dirty and the frame on
+     * screen is the one from before the gesture. The ticker hides this for the
+     * walking, which arrives on its own state change - it is only the pointer,
+     * which moves the body between ticks, that has to say so.
+     */
+    const [, moved] = useState(0);
+    const repaint = () => moved((count) => count + 1);
+    if (running && motion) {
+        // Walls from the creature's widest drawing, settled at registration, so
+        // they hold still while the pose changes underneath them.
+        const world = {
+            ...WORLD,
+            floor: fieldHeight - 1,
+            left: motion.reach.left,
+            right: Math.max(motion.reach.left, fieldWidth - 1 - motion.reach.right),
+        };
+        // Once, and a flag rather than `now === 0`, which is only false after the
+        // first tick: until then every render put the body back where it started,
+        // so a pointer that carried it somewhere was undone by its own repaint.
+        if (!placed.current) {
+            placed.current = true;
+            body.current.y = world.floor;
+            body.current.x = Math.max(world.left, Math.min(world.right, Math.floor(fieldWidth / 3)));
+        }
+        // `useFrame` answers zero while animation is off, so a beat that went
+        // backwards is the runtime saying stop rather than a dropped frame.
+        const ticks = beat < seen.current ? 0 : Math.min(beat - seen.current, MAX_CATCHUP);
+        seen.current = beat;
+        for (let tick = 0; tick < ticks; tick += 1)
+            stepBody(body.current, motion, mood, world, 1 / MOTION_FPS);
+        // The body's clock runs while it is held, so a grip nothing has touched
+        // for a while is a gesture that ended where this handler could not see -
+        // a release outside the terminal, which is never reported at all.
+        if (drag.current && slipped(body.current, drag.current)) {
+            release(body.current);
+            drag.current = null;
+        }
+        const pose = poseOf(body.current, motion, mood);
+        const at = poseFrames(chosen, pose, body.current.facing, mood);
+        const shape = at ? metric(at[0]) : { width: 1, height: 1, anchor: 0 };
+        const anchor = at ? anchorOf(at) : 0;
+        /**
+         * The pointer, which is the one input this has that a terminal figure
+         * has never had.
+         *
+         * Returning `true` on the way down claims the gesture: every `drag` and
+         * the `up` that ends it come back here wherever the pointer has got to,
+         * which is what lets a creature be carried off the field and dropped
+         * somewhere else rather than being lost the moment it leaves its own box.
+         *
+         * Picking it up is not the same as calling it. A press on the figure
+         * carries it; a press anywhere else in the field is somewhere to go, and
+         * the brain is told rather than the body moved - so it walks over, in
+         * its own gait, and a bunny hops there.
+         */
+        const onMouse = (event) => {
+            const held = body.current;
+            const x = event.x - rect.x;
+            const y = event.y - rect.y;
+            if (event.action === 'down' && event.button === 'left') {
+                const over = x >= held.x - anchor - 1 && x <= held.x - anchor + shape.width
+                    && y >= held.y - shape.height + 1 && y <= held.y + 1;
+                if (over) {
+                    drag.current = grab(held, x, y);
+                    repaint();
+                    return true;
+                }
+                held.intent = { kind: 'goto', x: clamp(x, world.left, world.right), until: held.now + 10 };
+                held.sitting = false;
+                held.stillFor = 0;
+                // The same question the brain asks itself, asked of where the finger
+                // landed: far enough away, or up in the air, is worth taking off for.
+                held.wantsFlight = motion.flies
+                    && (Math.abs(held.intent.x - held.x) > 14 || y < world.floor - 4);
+                repaint();
+                return true;
+            }
+            if (!drag.current)
+                return undefined;
+            // Only a press takes hold. A drag reaches this handler either because
+            // the press did - the runtime gives the rest of a gesture to whoever
+            // claimed it - or because the pointer passed over the figure during
+            // somebody else's unclaimed drag, and the second must not snatch the
+            // creature into a hand that was doing something else entirely.
+            if (event.action === 'drag') {
+                carry(held, drag.current, x, y, world, event.at);
+                repaint();
+                return true;
+            }
+            // A pointer moving with no button down is a pointer that was released
+            // while this handler was not being told.
+            if (event.action === 'move') {
+                release(held);
+                drag.current = null;
+                repaint();
+                return undefined;
+            }
+            if (event.action === 'up') {
+                release(held, drag.current);
+                drag.current = null;
+                repaint();
+                return true;
+            }
+            return undefined;
+        };
+        const field = Array.from({ length: fieldHeight }, () => ' '.repeat(fieldWidth));
+        const painted = at
+            ? blit(field, fill(at[frameOf(pose, body.current, at.length)], faceOf(pose, body.current, motion, mood), motion.tells[mood]), body.current.x, body.current.y, anchor)
+            : field;
+        return (_jsx(Column, { align: "start", onMouse: onMouse, ...rest, children: painted.map((row, at2) => (_jsx("text", { content: row, fg: tone ?? TONE[mood] }, `${chosen}-live-${at2}`))) }));
+    }
+    const frames = creatureFrames(chosen, mood, form);
+    const rows = frames[(animated ? frame : 0) % frames.length];
+    // No `unicode` check, which is the point of the alphabet: there is no
+    // ASCII fallback to swap in because there is nothing here to fall back
+    // from. The figure that renders on a terminal that can draw anything is
+    // the same figure that renders on one that can draw nothing.
+    return (_jsx(Column, { align: "center", ...rest, children: rows.map((row, at) => (_jsx("text", { content: row, fg: tone ?? TONE[mood] }, `${chosen}-${at}`))) }));
+});

package/dist/src/view/bood/sprite.d.ts

@@ -0,0 +1,18 @@
+import type { RenderOutput } from '@textui/core';
+import type { Mood } from './types.js';
+export interface BoodSpriteProps {
+    /** Which creature. One is chosen per run and kept in the store. */
+    name?: string;
+    mood?: Mood;
+    /**
+     * The row to stand on, when something on the screen has said which.
+     *
+     * The composer says so, and so does the block that appears when a tool asks
+     * for permission. Left out - a screen with nothing at the bottom - the floor
+     * is the bottom of the terminal less `inset`.
+     */
+    floor?: number;
+    /** Rows kept clear at the bottom of the terminal when nothing has said. */
+    inset?: number;
+}
+export declare const BoodSprite: (props: BoodSpriteProps) => RenderOutput;

package/dist/src/view/bood/sprite.js

@@ -0,0 +1,130 @@
+import { jsx as _jsx } from "@textui/core/jsx-runtime";
+import { defineComponent, useFrame, useRef, useSize, useState } from '@textui/core';
+import { Column } from '@textui/widgets';
+import { anchorOf, fill } from './art.js';
+import { carry, createBody, faceOf, frameOf, grab, poseOf, release, slipped, stepBody, WORLD, } from './motion.js';
+import { creatureMotion, poseFrames } from './registry.js';
+/**
+ * The creature, on the whole application rather than on one screen of it.
+ *
+ * It lives on the `floating` layer, which is a plane over every screen: it is
+ * not remounted by navigating, so pressing escape moves the screen out from
+ * under it and leaves the creature where it was standing. A figure that only
+ * exists on the screen that drew it is a decoration; one that is still there
+ * when the screen changes is an inhabitant, and that is the whole difference.
+ *
+ * Nothing here draws a field. The wrapper is a box that states no background,
+ * and a box that states nothing paints nothing - so the only cells this writes
+ * are the ones the animal's own rows occupy. That is the constraint the whole
+ * design turns on: a terminal has no per-cell transparency, so a rectangle of
+ * padding would erase a rectangle of the application. A creature-shaped hole
+ * is the most a sprite can cost, and it is what this costs.
+ */
+const MOTION_FPS = 12;
+const MAX_CATCHUP = 4;
+const clamp = (value, low, high) => (value < low ? low : value > high ? high : value);
+export const BoodSprite = defineComponent('BoodSprite', (props) => {
+    const { name, mood = 'happy', floor, inset = 3 } = props;
+    const size = useSize();
+    const motion = name ? creatureMotion(name) : undefined;
+    const body = useRef(createBody());
+    const placed = useRef(false);
+    const seen = useRef(0);
+    const drag = useRef(null);
+    // The body is a ref, so moving it by hand changes nothing the runtime can
+    // see. The ticker covers the walking; the pointer has to say so itself.
+    const [, moved] = useState(0);
+    const beat = useFrame(MOTION_FPS, { enabled: motion !== undefined });
+    if (!motion || !name)
+        return null;
+    const world = {
+        ...WORLD,
+        floor: Math.max(1, Math.min(floor ?? Infinity, size.height - inset - 1)),
+        left: motion.reach.left,
+        right: Math.max(motion.reach.left, size.width - 1 - motion.reach.right),
+    };
+    if (!placed.current) {
+        placed.current = true;
+        body.current.y = world.floor;
+        body.current.x = clamp(Math.floor(size.width / 3), world.left, world.right);
+    }
+    // The floor is not the same height on every screen - a composer keeps a
+    // lot more of the bottom than a status bar - so moving between them moves
+    // the ground. Above it, the creature falls to the new one rather than
+    // standing on the height the last screen had.
+    body.current.y = Math.min(body.current.y, world.floor);
+    if (body.current.y < world.floor && body.current.grounded)
+        body.current.grounded = false;
+    const ticks = beat < seen.current ? 0 : Math.min(beat - seen.current, MAX_CATCHUP);
+    seen.current = beat;
+    for (let tick = 0; tick < ticks; tick += 1)
+        stepBody(body.current, motion, mood, world, 1 / MOTION_FPS);
+    // The clock runs while it is held, so a grip nothing has touched for a
+    // while is a gesture that ended somewhere this handler could not see.
+    if (drag.current && slipped(body.current, drag.current)) {
+        release(body.current);
+        drag.current = null;
+    }
+    const pose = poseOf(body.current, motion, mood);
+    const frames = poseFrames(name, pose, body.current.facing, mood);
+    if (!frames)
+        return null;
+    const raw = frames[frameOf(pose, body.current, frames.length)];
+    const anchor = anchorOf(frames);
+    const rows = fill(raw, faceOf(pose, body.current, motion, mood), motion.tells[mood]);
+    const left = Math.max(0, Math.round(body.current.x) - anchor);
+    const top = Math.max(0, Math.round(body.current.y) - rows.length + 1);
+    /**
+     * Only what is actually on the animal.
+     *
+     * There is no full-screen catcher: the node is the creature's own box, so
+     * the runtime's hit test has already decided this press was on the figure
+     * and every other press in the application never reaches here. An overlay
+     * that covered the terminal to listen would be one that broke every
+     * control it happened to be standing over.
+     */
+    const onMouse = (event) => {
+        const held = body.current;
+        if (event.action === 'down' && event.button === 'left') {
+            drag.current = grab(held, event.x, event.y);
+            moved((count) => count + 1);
+            return true;
+        }
+        if (!drag.current)
+            return false;
+        // Only a press takes hold. A drag reaches this handler either because
+        // the press did - the runtime gives the rest of a gesture to whoever
+        // claimed it - or because the pointer happened to pass over the figure
+        // during somebody else's unclaimed drag, and the second must not snatch
+        // the creature into a hand that was doing something else entirely.
+        if (event.action === 'drag') {
+            carry(held, drag.current, event.x, event.y, world, event.at);
+            moved((count) => count + 1);
+            return true;
+        }
+        // A pointer moving with no button down is a pointer that was released
+        // while this handler was not being told: the terminal reports the
+        // motion but never reported the release.
+        if (event.action === 'move') {
+            release(held);
+            drag.current = null;
+            moved((count) => count + 1);
+            return false;
+        }
+        if (event.action === 'up') {
+            release(held, drag.current);
+            drag.current = null;
+            moved((count) => count + 1);
+            return true;
+        }
+        return false;
+    };
+    // The layer is pinned at the top-left of the terminal and states no
+    // background, so the margin is the position and the only cells written are
+    // the ones the animal's own rows occupy.
+    return (_jsx(Column, { margin: [top, 0, 0, left], onMouse: onMouse, children: rows.map((row, at) => (_jsx("text", { content: row, fg: TONE[mood] }, `bood-${at}`))) }));
+});
+/** The same tones the still figure uses, so the two never disagree. */
+const TONE = {
+    happy: 'success', sad: 'muted', thinking: 'info', executing: 'accent', error: 'danger',
+};

package/dist/src/view/bood/sprout.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A sprout. Not an animal, and the only one here with a face that is two eyes
+ * and no mouth - which is what lets the leaves do the talking.
+ *
+ * Leaves up and open, drooping when things are not going well, spread when
+ * they are going badly. The pot never changes; everything above it does.
+ */
+export declare const sprout: import("./types.js").CreatureSpec;

package/dist/src/view/bood/sprout.js

@@ -0,0 +1,121 @@
+import { alternate, art, blink } from './art.js';
+import { defineCreature } from './types.js';
+/**
+ * A sprout. Not an animal, and the only one here with a face that is two eyes
+ * and no mouth - which is what lets the leaves do the talking.
+ *
+ * Leaves up and open, drooping when things are not going well, spread when
+ * they are going badly. The pot never changes; everything above it does.
+ */
+export const sprout = defineCreature({
+    name: 'sprout',
+    label: 'Sprout',
+    about: 'Newer than the rest of this, and growing',
+    draw: {
+        happy: blink(art `
+   \|/
+   _|_
+  (^ ^)
+  (\v/)
+   | |
+`, art `
+   \|/
+   _|_
+  (- -)
+  (\V/)
+   | |
+`),
+        sad: art `
+   ,|,
+   _|_
+  (T T)
+  (\v/)
+   | |
+`,
+        thinking: alternate(art `
+   \|/  o
+   _|_
+  (o -)
+  ( v )
+   | |
+`, art `
+   \|/  .
+   _|_
+  (o -)
+  ( V )
+   | |
+`),
+        executing: [art `
+   \|/
+   _|_
+  (o o)
+ /( V )\
+   | |
+`, art `
+   \|/
+   _|_
+ _(o -)_
+  ( v )
+   | |
+`, art `
+   \|/
+   _|_
+  (- o)
+ /( V )\
+   | |
+`],
+        error: art `
+   /|\
+   _|_
+  (> <)
+  (/W\)
+   | |
+`,
+    },
+    block: {
+        happy: blink(art `
+ \|/
+(^ ^)
+ |V|
+`, art `
+ \|/
+(- -)
+ |V|
+`),
+        sad: art `
+ ,|,
+(T T)
+ |V|
+`,
+        thinking: art `
+ \|/
+(- o)
+ |V|
+`,
+        executing: [art `
+ \|/
+(o o)
+ |V|
+`, art `
+ \|/
+(o -)
+ |V|
+`, art `
+ \|/
+(- o)
+ |V|
+`],
+        error: art `
+ /|\
+(> <)
+ |V|
+`,
+    },
+    inline: {
+        happy: blink(art `\^v^/`, art `\-,-/`),
+        sad: art `,TvT,`,
+        thinking: art `\-,o/`,
+        executing: [art `\o,o/`, art `\o,-/`, art `\-,o/`],
+        error: art `/>.</`,
+    },
+});

package/dist/src/view/bood/types.d.ts

@@ -0,0 +1,158 @@
+/**
+ * What a creature is, before anyone draws one.
+ *
+ * A creature file writes art and nothing else - no measuring, no padding, no
+ * component. The registry does the arithmetic once, at registration, so that
+ * a drawing is checked the moment it joins the bood rather than the first
+ * time somebody renders it on a narrow terminal.
+ */
+/** What the figure is doing. The one thing worth reading from across the room. */
+export declare const MOODS: readonly ["happy", "sad", "thinking", "executing", "error"];
+export type Mood = typeof MOODS[number];
+/**
+ * How much room the figure gets.
+ *
+ * Three sizes rather than one scaled one, because art does not scale: a cat
+ * shrunk to five cells is a smudge, and a cat *redrawn* at five cells is a
+ * cat. Each form is drawn by hand and each one is allowed to look different.
+ */
+export declare const FORMS: readonly ["draw", "block", "inline"];
+export type Form = typeof FORMS[number];
+/**
+ * The ceiling each form is held to.
+ *
+ * `block` and `inline` exist to be placed next to something else - a header, a
+ * status row, a list item - and a caller who has budgeted seven cells cannot
+ * have that budget decided by whichever creature came up. So the bound is the
+ * contract, and `registerCreature` refuses art that breaks it.
+ *
+ * `draw` has no width bound on purpose. The figures run from seven cells wide
+ * to seventeen and the outline *is* the animal; a creature that fits a
+ * template is a template wearing a hat.
+ */
+export declare const BOUNDS: Record<Form, {
+    rows: number;
+    cols: number;
+}>;
+/**
+ * One still, as rows. `art` produces these.
+ *
+ * A cell is one of them, or several to cycle through. Frame zero is the
+ * still: it is what shows with animation off, on a terminal that has said no,
+ * and in a snapshot test - so it is the frame worth getting right.
+ */
+export type Cell = string[] | string[][];
+/**
+ * What the body is doing, as distinct from what the mood is.
+ *
+ * Nothing sets one of these. A pose is derived from the physics every tick -
+ * `poseOf` in `motion.ts` - because a body that is told what it is doing and a
+ * body that is falling are two authorities on one fact, and the visible half
+ * of that disagreement is a figure walking through the air.
+ */
+export declare const POSES: readonly ["idle", "sit", "walk", "jump", "fall", "fly", "land", "held", "sleep", "alarm"];
+export type Pose = typeof POSES[number];
+/**
+ * Which way it is pointed, which is latched rather than read.
+ *
+ * `front` is the one a creature returns to: after a couple of seconds standing
+ * still it turns and looks at you. It is also the fallback, so a species that
+ * has no left view of a pose falls through to its front one and still reads
+ * right rather than drawing nothing.
+ */
+export declare const FACINGS: readonly ["front", "right", "left"];
+export type Facing = typeof FACINGS[number];
+/** How motion art is keyed: a pose, or a pose at one facing. */
+export type PoseKey = Pose | `${Pose}.${Facing}`;
+/**
+ * The moving half of a creature, which is optional.
+ *
+ * A creature without this is drawn exactly as it always was; `lively` simply
+ * has nothing to run. That is the whole reason it is a separate block rather
+ * than more fields on the spec - three of the six here have side views drawn
+ * for them and three do not, and the three that do not are not broken.
+ *
+ * The art here is keyed on `pose`, never on mood, because mood arrives through
+ * the slots instead: a run of `%` is the face and a run of `#` is the tell -
+ * ears, tail, crest. The run is exactly as wide as the token that fills it, so
+ * substitution cannot move a column, and `registerCreature` checks that rather
+ * than trusting it. Without that seam the matrix is poses x facings x moods
+ * and nobody draws five hundred pictures of a rabbit.
+ */
+export interface Motion {
+    /** `hop` cannot travel without leaving the ground. `walk` can. */
+    gait: 'walk' | 'hop';
+    /** Whether gravity can be suspended for this one while it has somewhere to be. */
+    flies: boolean;
+    sits: boolean;
+    /** How much of an impact comes back up. Zero for a cat, which does not bounce. */
+    bounce: number;
+    /** Gravity multiplier. Below one is a creature the air holds up. */
+    fallSpeed: number;
+    /** One gait hop, as a fraction of the standard impulse. Ignored by a walker. */
+    hop: number;
+    /** What a restful pose blinks with, whatever mood it is in. */
+    blink: string;
+    /** The mood token, three cells, dropped into every `%` run. */
+    faces: Record<Mood, string>;
+    /** The second carrier of the same meaning, dropped into every `#` run. */
+    tells: Record<Mood, string>;
+    poses: Partial<Record<PoseKey, Cell>>;
+    /**
+     * A mood that changes the shape rather than the expression.
+     *
+     * The escape hatch the face slot cannot cover: a cat that is working sits at
+     * a keyboard, which is a different animal outline and not a different face.
+     */
+    overrides?: Partial<Record<Mood, Partial<Record<PoseKey, Cell>>>>;
+}
+/** What a creature file exports: art, in three sizes, in five moods. */
+export interface CreatureSpec {
+    /** The registry key. Lowercase, one word. */
+    name: string;
+    /** For a picker, or a roster. */
+    label: string;
+    /** One line about what it is, where a picker has room for one. */
+    about?: string;
+    draw: Record<Mood, Cell>;
+    block: Record<Mood, Cell>;
+    inline: Record<Mood, Cell>;
+    /** Present on the creatures that have been drawn moving. */
+    motion?: Motion;
+}
+/** Motion as the registry keeps it: the same art, framed and slot-checked. */
+export interface RegisteredMotion extends Omit<Motion, 'poses' | 'overrides'> {
+    poses: Partial<Record<PoseKey, string[][]>>;
+    overrides: Partial<Record<Mood, Partial<Record<PoseKey, string[][]>>>>;
+    /**
+     * How far the widest drawing reaches either side of the anchor.
+     *
+     * The walls are set from this rather than from whichever frame is up, so
+     * they do not move. A bound taken from the current pose shrinks the moment
+     * a cat turns side-on and doubles in width, and the creature - already
+     * standing legally where it was - is shoved several cells inward on the
+     * next tick. Constant walls cost it half a body length at each end and
+     * nothing else.
+     */
+    reach: {
+        left: number;
+        right: number;
+    };
+}
+/** What the registry hands back: the same art, measured and squared off. */
+export interface Creature {
+    name: string;
+    label: string;
+    about: string;
+    /** form to mood to frames to rows. Every row of a form is one width. */
+    art: Record<Form, Record<Mood, string[][]>>;
+    /** What a form costs, whatever mood it is in. Settled at registration. */
+    size: Record<Form, {
+        width: number;
+        height: number;
+    }>;
+    /** Undefined on a creature nobody has drawn a walk cycle for. */
+    motion?: RegisteredMotion;
+}
+/** Identity, for the type inference. A creature file is data, and stays data. */
+export declare const defineCreature: (spec: CreatureSpec) => CreatureSpec;