buffer(w: number, h: number, palette: { any }) → any

Build a drawing buffer over a palette. `palette` is the ordered array of `{ name = , color = }` entries the canvas was created with; the buffer resolves colour names to that exact index order.

clear(self: any) → void

cells(self: any) → void

bbox(self: any) → any

The drawn extent of this frame, or nil when nothing was drawn. A frame whose ink touches the cell edge is a pose reaching further than the sheet allows, and the only way to find one across 240 frames is to measure.

i(self: any, name: string?) → number

px(self: any, x: number, y: number, ci: number) → void

Every primitive takes a resolved INDEX, not a name, so the inner loops stay arithmetic. `Ink.body` and the costume hooks resolve once per shape.

rect(self: any, x0: number, y0: number, x1: number, y1: number, ci: number) → void

blob(self: any, cx: number, cy: number, rx: number, ry: number, ci: number) → void

A filled ellipse — heads, fists, shoulders, pauldrons, lantern glass.

limb(self: any, x0: number, y0: number, x1: number, y1: number, w0: number, w1: number, ci: number) → void

A tapered capsule. Arms, legs, torso, coat tails, cable, chain — the taper is what keeps a figure from reading as a stack of rectangles.

line(self: any, x0: number, y0: number, x1: number, y1: number, ci: number, thick: number?) → void

poly(self: any, pts: { { number } }, ci: number) → void

A closed filled polygon (scanline). Points are `{ {x,y}, ... }`.

ribbon(self: any, pts: { { number } }, w0: number, w1: number, ci: number) → void

A tapering strip through a point list — scarves, coat tails, cable, hair.

speck(self: any, cx: number, cy: number, rx: number, ry: number, ci: number, density: number?, seed: number?) → void

Deterministic scattered pixels in an ellipse — sparks, ash, soot, grit.

burst(self: any, cx: number, cy: number, r: number, spokes: number, ci: number, phase: number?) → void

A radiating burst — the shape under every furnace-light effect in the game.

volume(self: any, ramp: { [number]: { number } }) → void

Volume. Walk each row, find maximal runs of one material, and push the first `dark` columns of the run to its shadow tone and the last `lit` columns to its highlight. Every stage in Kessai keys from screen-right, so the light lands on a fighter's leading edge — and because it is done per RUN rather than per silhouette, an arm crossing a coat gets its own rounding instead of a flat cut-out.

grit(self: any, fromIdx: number, toIdx: number, density: number) → void

Wear. Replace a deterministic scatter of one material with another — soot on a coat, rust on a gauntlet, scuffing on leather. Keyed off the cell address alone, so the same pixel wears the same way in every frame and the grain does not crawl during an animation.

outline(self: any, ci: number) → void

One-pixel rim around every drawn cluster, run LAST. A fighting-game sprite without a hard outline disappears into a painted stage.

finish(self: any, S: any) → void

Volume, wear and outline in the order a finished cell wants them.

down(a: number) → void

Angles are degrees. 0 is straight down for a limb and straight up for the torso; positive turns toward +x, which is the direction the sheet faces. The combat slice mirrors the entity to face the other way, so everything here is drawn facing screen-right and only ever facing screen-right.

up(a: number) → void

solve(P: any, S: any) → any

Solve a pose into world (sheet) joint positions. Returns `{ pelvis, chest, neck, head, shF, shB, elF, elB, hdF, hdB, knF, knB, ftF, ftB }`, each `{x, y}`, plus `lean` and `scale`.

arm(sx0: number, sy0: number, a: number, b: number) → void

The forearm angle is ABSOLUTE, not a flexion off the upper arm: in a fighting sheet you pose an arm by deciding where the fist points, and a relative elbow makes that two sums in your head and the sign of the flexion easy to get backwards. The knee stays relative, because a knee is a hinge that only bends one way and reads naturally as "bend".

leg(a: number, b: number) → void

body(B: any, J: any, S: any, P: any) → void

Draw the figure back-to-front. `S.mat` names the materials; a `*B` entry is the far-side tone, which is what separates the two arms and the two legs without an outline between them.

legPart(B: any, hipP: any, knP: any, ftP: any, S: any, iPant: number, iBoot: number, footA: number, sy: number, k: number) → void

armPart(B: any, shP: any, elP: any, hdP: any, S: any, iSkin: number, handA: number, k: number) → void

torso(B: any, J: any, S: any, iBody: number) → void

head(B: any, J: any, S: any, P: any, iSkin: number) → void

chain(n: number, x: number, y: number, seg: number) → void

A coat tail and a scarf are follow-chains: pixelkit relaxes each segment toward the one in front of it with lag, so cloth leads into a movement a frame late and keeps travelling after the body has stopped. The chain is state that persists ACROSS the frames of a clip, which is the whole point — rebuild it per frame and the cloth is rigid. Create a chain of `n` points seeded hanging from (x, y).

flow(ch: { { number } }, ax: number, ay: number, seg: number, lag: number, gravity: number, wx: number, wy: number, floorY: number?) → void

Advance a chain one frame. `wx`/`wy` is the wind/inertia push applied to every segment past the first, scaled down the length so the tip whips.

settle(ch: { { number } }, ax: number, ay: number, seg: number, lag: number, gravity: number, iter: number) → void

Settle a chain by running it `iter` times with no wind — the shape cloth reaches when the fighter has been standing still.

pose(base: any, ...: ?) → any

Merge `over` onto a copy of `base`. Poses are flat number tables, so this is how a stance becomes a wind-up without restating twenty joints.

clip(fps: number, loop: boolean, keys: { any }) → any

A clip from key poses. `keys` is pixelkit's shape: `{ { pose = P, hold = n, ease = "outQuad" }, ... }`.

cycleClip(fps: number, keys: { any }, n: number) → any

A seamless looping clip. `keys` are `{ pose = P, at = 0..1, ease? }` around a cycle that WRAPS, so the last frame leads back into the first instead of landing on a copy of it — which is what a breathing idle and a walk cycle need and what a straight key list cannot give.

buildSheet(handle: any, S: any, clips: { [string]: any }, order: { string }, drawPose: (any, any) → void

Write every clip into the canvas and hand back the clip index the combat slice drives by name. One `addFrame` per frame; the blank frame the canvas is born with is removed at the end so clip frame numbers start at 1.

auditSheet(S: any, clips: { [string]: any }, order: { string }, drawPose: (any, any) → void

Draw the whole sheet into a buffer PADDED on every side and report which clips put ink outside the real cell. A primitive clamps to the buffer it draws into, so a pose that reaches past the sheet edge does not fail — it silently loses the part that did not fit, and across 240 frames the only way to find one is to give the drawing room to overflow into and then measure what landed there. Returns `{ [clipName] = { over = n, left, right, top, bottom } }`, empty when every frame fits.