{
 "what": "Every experiment of the Lab, from each lab/<slug>/experiment.json. Generated by admin/build/build.py.",
 "site": "https://storyboards.sgit.ai",
 "experiments": [
  {
   "slug": "flowchart",
   "title": "A flowchart, explained",
   "track": "deeper",
   "question": "Can a diagram people already write (Mermaid) become a storyboard that explains itself, node by node?",
   "summary": "Mermaid text in, a graph laid out by dagre and drawn in the kit's ink, and a character who walks it along the edges, lighting each node and saying what it is for.",
   "kit": "v0.1.0",
   "libraries": [
    "dagre-1.1.4.min.js"
   ],
   "order": 1,
   "status": "promising",
   "date": "2026-10-20",
   "learnt": [
    "The notes are the storyboard: the chart's nodes are the settings, the %% note lines are the lines spoken. Writing them showed which nodes were two steps pretending to be one.",
    "Layout is somebody else's problem and should stay so: dagre placed every example first time; the kit should draw what a layout engine returns, not grow its own.",
    "A walker needs a path, not a graph: explaining is linear even when the chart is not, so %% path is the author's one story through the diagram.",
    "Mermaid's syntax is enough and already everywhere: a chart from a README can be explained without being redrawn.",
    "The camera wants to follow: on a tall chart the walker leaves the screen; zooming the viewBox to the current node is the next step."
   ]
  },
  {
   "slug": "camera",
   "title": "Camera: one world, many beats",
   "track": "layout",
   "question": "Can a storyboard be one wide scene that a camera moves across, and can a scene hold another scene?",
   "summary": "Three of the kit's panels side by side as one world; the camera pans and zooms between beats written as data, and zooms into a laptop whose screen is another panel drawn by the same kit.",
   "kit": "v0.1.0",
   "libraries": [],
   "order": 1,
   "status": "promising",
   "date": "2026-10-20",
   "learnt": [
    "A viewBox is a camera, and it is enough: pan, zoom and a hold are three numbers and a time, and the sketch stays sharp at 8x because it was never pixels.",
    "A storyboard can show a storyboard: the laptop's screen is a nested svg the kit drew a different scene into. Any prop with a face can hold a scene.",
    "The world is three panels because the kit draws panels; a continuous floor hides the seams, a setting per panel does not. A world kind in the data is the honest next step.",
    "Beats and actions want to be one script: this page moves the camera, the Stage experiment moves the actors, and the same timeline should carry both.",
    "Holding still is a beat too: without a hold the camera never arrives anywhere."
   ]
  },
  {
   "slug": "stage",
   "title": "Stage",
   "track": "motion",
   "question": "Can a storyboard's actors be directed like a game, from a script of verbs, and can playing the game write the script?",
   "summary": "A script of verbs (enter, walk, say, think, camera) the actors carry out, drawn by the kit's own drawCharacter; a timeline, a scrubber, and a direct mode where the arrow keys move an actor and what you do is written into the script.",
   "kit": "v0.1.0",
   "libraries": [],
   "order": 1,
   "status": "promising",
   "date": "2026-10-20",
   "learnt": [
    "The script is a storyboard with time in it: a panel is a script where every action is at t = 0, and a played script is a panel at every t. One data file can hold both.",
    "Redraw on change, move by transform: drawing a character once per pose and mood and moving the group keeps Rough.js still; redrawing every frame makes the sketch boil.",
    "Direct mode is the editor nobody has to learn: walking an actor with the arrow keys and typing a line writes the actions with their times. Playing the game wrote the data.",
    "What the kit should export next: its bubble, caption and setting as functions, and a walk pose. This page redraws its own bubble in the kit's ink to get round it.",
    "Timing needs a grammar: 'when their last line ends' was enough for two actors; a third and a camera wanted at and wait. A tiny timeline language is the next experiment, not a bigger JSON."
   ]
  },
  {
   "slug": "threat-model",
   "title": "A threat model, probed",
   "track": "deeper",
   "question": "Can a threat model (a data-flow diagram and its STRIDE findings) be played as a storyboard instead of read as a table?",
   "summary": "A data-flow diagram as data, drawn in the kit's ink; the attacker walks to each flow and asks a STRIDE question, the author's answer appears red (open) or green (mitigated), and the watcher's face follows.",
   "kit": "v0.1.0",
   "libraries": [],
   "order": 2,
   "status": "promising",
   "date": "2026-10-20",
   "learnt": [
    "The attacker is the best narrator: a threat is a question somebody asks at a flow, and drawing the person asking turns a table row into a scene with a point of view.",
    "Open and mitigated are the only two moods a finding needs: red or green on the card, worried or calm on the watcher's face. A severity scale would have been a verdict.",
    "The DFD wants its own drawing vocabulary: entity, process, store, boundary are four shapes, all a prop pack away. This page draws them itself.",
    "A review is a path through the flows, like a flowchart's: the order the author probes them in is part of the argument and the data should carry it.",
    "A model this size fits a panel; a real one will not. Twelve flows need the camera and a chapter per boundary."
   ]
  },
  {
   "slug": "sequence",
   "title": "A sequence diagram",
   "track": "deeper",
   "question": "What does a sequence diagram gain when its lifelines are characters with faces, and what does a text language for its messages need?",
   "summary": "A sequence diagram with the lab cast as lifelines, messages from a tiny text language, envelopes that travel, arrows that draw themselves and faces that react.",
   "kit": "v0.1.0",
   "libraries": [],
   "status": "promising",
   "date": "2026-10-20",
   "learnt": [
    "Characters give a sequence diagram a reaction, which a box never has. A UML lifeline says who sent what; a face at the top says how it landed. Vex's lifeline reads as an attack before any arrow arrives, because Vex looks like Vex, and a vault that answers with a padlock says more than a return arrow. The mood suffix on a line became the most used part of the language.",
    "The DSL needed four things and no more: a solid arrow, a dashed reply, a note over one lifeline, and a mood in square brackets, plus an error that names the line and shows the three shapes it accepts. What it does not have and wanted at once: a message to oneself, an activation bar on a lifeline, and two messages at the same time. Status: the four shapes work; the rest is parked.",
    "The layout fights the drawing at the top and at the labels. The kit's figures are 510 panel units tall and stand on a floor, so at half size the header takes 265 of the diagram's units before the first message, and the vault had to be drawn by hand to the pack's look to stand at the same height. A label longer than the gap between two lifelines crosses the next one, so this page wraps labels at 26 characters and gives a long message a taller row: the diagram grows down, never sideways.",
    "One state count drives everything. Play, step and the scrubber all call setState(k): messages under k are shown, the rest hidden, and each face is the last mood its lifeline received, redrawn from the same seed so only the face moves. The envelope (600 ms, requestAnimationFrame) and the arrow's draw-in (350 ms) are the only things that happen in time, and both are skipped when the reader scrubs or asks for reduced motion.",
    "A CSS draw-in that depends on an attribute selector did not start in Chromium 141. The first version revealed an arrow by toggling a class on its group and let a rule on path[pathLength] draw the stroke; the class changed, the paths were never restyled, and the arrows stayed invisible until something else touched them. The kit's own play() uses the same shape of rule and shows the same symptom in this browser (the scrolly experiment has the one-line nudge). This page sets the dash offset inline and draws the stroke with element.animate, which works everywhere tried. Status: a bug to report against the kit's CSS, with the fix of classing the paths instead of selecting them by attribute."
   ]
  },
  {
   "slug": "cast-designer",
   "title": "Cast designer",
   "track": "characters",
   "question": "Which look fields make a character, and what does a cast file need that the drawing does not?",
   "summary": "A live character designer on the kit's drawCharacter: every look field as a control, two previews that redraw as you type, a random button, and the cast JSON ready to copy.",
   "kit": "v0.1.0",
   "libraries": [],
   "status": "promising",
   "date": "2026-10-20",
   "learnt": [
    "The fields that matter, in order, at panel size: the shirt colour (the biggest flat area), the hair shape (the silhouette), the skin, then the accessory. Trousers barely register, because the legs are thin strokes; a height of 0.8 against 1.2 only reads when two people stand side by side. Two people with the same shirt colour and hair shape are one person.",
    "A cast file needs what the drawing never reads: id, name, pronouns, role. The drawing reads what nobody would write by hand: height to two decimals. The designer writes exactly the cast format so the file is the only contract, and it hides hatColour unless the hair is a beanie and accentColour unless there are headphones or a lanyard, which the format itself does not.",
    "Random is only plausible with palettes. A random hex for skin makes a green person and a random shirt on random trousers makes a clown, so the random button draws from six skins, eight hair colours and ten shirts that live in this page. Those palettes belong in the kit as data, so a story can ask for a plausible stranger with one call.",
    "The second preview catches what the first hides. Ines, with long near-black hair, loses raised brows (surprised, worried) against the fringe, because the kit draws brows in ink over hair of almost the same colour; a thinking hand sits in front of a lanyard's cord. The small figure at another pose and mood showed both. One preview is not a check; the model sheet is."
   ]
  },
  {
   "slug": "cinematic",
   "title": "Cinematic",
   "track": "motion",
   "question": "What does a real animation timeline (scrubbing, speed, easing) give a kit panel that the kit's CSS play cannot, and what in the kit's markup helps or hinders it?",
   "summary": "One kit panel choreographed with an anime.js timeline: setting, prop, entrances with overshoot, bubbles word by word, caption, with a scrubber, speed and easing controls.",
   "kit": "v0.1.0",
   "libraries": [
    "anime-3.2.2.min.js"
   ],
   "status": "promising",
   "date": "2026-10-20",
   "learnt": [
    "A real timeline gives three things a CSS class cannot: a scrubber (seek to any millisecond, forwards or back, while paused), a speed, and an easing you can swap and compare on the same panel. The kit's play() gives one run at one speed with no way back. The cost is about sixty lines of choreography for one panel against one class, and a vendored library; a storyboard with forty panels would want the choreography written once from data, not by hand per panel.",
    "The kit's markup made the big groups easy and the details hard. actor, prop, scenery and pop found everything the timeline moves. What took digging: the floor line is a bare ink group found only by its position in the setting; the caption and the bubbles share the class pop and differ only by a style attribute; a bubble carries no link to its speaker (document order says whose it is); which side an actor enters from had to be read from the x of its name; and a bubble's lines are tspans with their own x and dy, so a word-by-word reveal has to keep the first word's attributes and fade the rest with fill-opacity, since opacity does not apply to a tspan.",
    "What to lift into the kit: a data-who on each actor and its bubble, a class on the caption and on the setting's floor, a transform-origin on pop, and an arrival list, the delays the kit already writes as --d, exposed as data ({ target, at }) so a page can build a timeline from it instead of guessing the order. With those, this page's choreography would be data too. Status: the page works; the lifts are proposals.",
    "The transforms are CSS transforms on SVG groups, and that works in Chromium with transform-box: fill-box, but the kit's own play uses them too and never says so; a translateX on an actor is in panel units because the group lives inside the viewBox, which is convenient and surprising. Scrubbing a word-by-word reveal is the one place the timeline shows its seams: words are discrete, so a seek lands between them and the sentence is half there, which reads as a glitch where the strokes and the slides read as a pause."
   ]
  },
  {
   "slug": "comic-page",
   "title": "Comic page",
   "track": "layout",
   "question": "What does a comic page, a filmstrip and a grid each want from the same seven panels, and what does panel size do to a scene?",
   "summary": "The same seven-panel storyboard laid out as an A4 comic page with a splash, a filmstrip and a 2 by 4 grid, with a print button.",
   "kit": "v0.1.0",
   "libraries": [],
   "status": "exploring",
   "date": "2026-10-20",
   "learnt": [
    "Small panels lose the words first: at a third of a 780px sheet the kit's 34px bubble text is under 5px tall, so the row of three reads as pictures (figure, prop, caption block); a small panel wants one figure, one prop and a caption of a few words.",
    "A splash is the cover's job; every other slot shape is a crop of a 16:10 drawing (the tall slot shows the middle 30% of the width, the wide one the lower 78% of the height), so panels 2, 6 and 7 were written for their slot, and the kit's top-left caption is hidden in cropped slots because a crop can show only half of it.",
    "A layout wants a size hint per panel (splash, wide, tall, small) that the author sets, and a drawScene that reads the svg's own aspect and places cast, bubbles and caption inside it instead of inside 16:10; this page hard-codes the slots. Status: a proposal.",
    "Panel numbers, the title block and the punchline belong to the layout: the seven svg elements move between layouts without a redraw, the punchline is a layout text under the last panel (a punchline panel printed it twice), and print fits the sheet to A4 with a stylesheet alone."
   ]
  },
  {
   "slug": "dialogue",
   "title": "Dialogue engine",
   "track": "motion",
   "question": "What happens to a storyboard when the reader chooses the next line and the text types itself out?",
   "summary": "A visual-novel scene on a kit panel: typed-out lines in a seeded Rough.js bubble, a branching script as data, and the reader's choices as buttons.",
   "kit": "v0.1.0",
   "libraries": [],
   "status": "exploring",
   "date": "2026-10-20",
   "learnt": [
    "A reader's choice turns a storyboard from a sequence into a graph, and the panel stops being the unit: the unit becomes the node (who, what, mood, pose) and a panel is whatever nodes the reader passed through. The log under the panel is the storyboard the reader wrote; two readers get two storyboards from the same script. For a deck, that means the still pictures cannot be rendered ahead of time unless every path is rendered, which for ten nodes with two forks is four strips.",
    "Typed text changes the pacing from the reader's to the author's. At 40 characters a second a line of 90 characters takes a little over two seconds to appear, and the reader waits for it; in a drawn bubble they read it in under a second and move on. The waiting is the point when a line should land (Oto's interruption reads better typed), and a cost everywhere else, which is why skip has to be one key and one click. Status: exploring.",
    "The data needs less than expected: an id, who speaks, the text, a mood and a pose, and either a next or a list of choices. What it also needs, and this page checks on apply, is a validator: a choice that points at a missing node is the error a reader hits last and an author hits first. What the data does not say yet, and would have to, is where people stand and when they enter; Oto's entrance is hard-coded here.",
    "The kit draws the people but not the bubble, so the bubble here is the page's own (a rounded rectangle and a tail, in the kit's ink, with the same Rough.js seed each redraw so the box does not boil while the text types). Changing a character's mood means redrawing the whole character with the same seed, which is quick but visible as a flicker on slow machines; a bubble and a face that could be updated in place are the two things to lift into a release."
   ]
  },
  {
   "slug": "gravity",
   "title": "Gravity",
   "track": "motion",
   "question": "What does a physics engine behind a storyboard panel add, what does it cost, and could a storyboard carry a drop as data?",
   "summary": "matter.js behind a kit panel: keys, envelopes and padlocks fall, bounce and pile up, and the characters react when one lands near them.",
   "kit": "v0.1.0",
   "libraries": [
    "matter-0.20.0.min.js"
   ],
   "status": "promising",
   "date": "2026-10-20",
   "learnt": [
    "Physics adds the one thing a storyboard never had: consequence. A dropped key lands where the world says, bounces off the envelope that fell before it, and settles at an angle nobody drew. The panel stops being a picture of a moment and becomes a place where moments happen, and the characters' surprise, triggered by a collision rather than a script, reads as a reaction. Status: promising for a demo, not yet for a storyboard.",
    "The cost is a frame loop that never stops. The engine steps and every prop's transform updates at 60 frames a second, whether or not anything is still moving; the readout shows the time a frame takes. The characters stay cheap because they are drawn once and only redrawn (a few dozen Rough.js paths each) when a prop lands near them. The panel also stops being reproducible: the same drops never pile the same way twice unless the engine is stepped on a fixed clock, which this page does.",
    "A storyboard could carry a \"drop\" action as data: { action: \"drop\", prop: \"key\", x: 0.3, at: 1.2 }, with the kit's prop drawing and a body of the same size, and the panel's still picture as the state after everything has settled (the reduced-motion path steps the world 300 times and draws the result). What it cannot carry is the exact pile; the author gets to choose what falls and where, not where it ends up.",
    "The kit's props are not exported as functions, so the key, envelope and padlock here are redrawn by the page in the pack's proportions; a kit release that exports its prop drawings with a size for each is the thing to lift. The surprised face needs the kit to redraw the whole character; a mood that could be swapped on a drawn character would make the reaction a two-line change."
   ]
  },
  {
   "slug": "ink-pack",
   "title": "Ink pack",
   "track": "characters",
   "question": "Can a second character pack, clean thick-line cartoon instead of sketch, keep the kit's contract and stay on model?",
   "summary": "The lab cast drawn twice, by the kit and by a plain-SVG ink pack with thick outlines and flat fills, from the same look fields, poses and moods.",
   "kit": "v0.1.0",
   "libraries": [],
   "status": "exploring",
   "date": "2026-10-20",
   "learnt": [
    "The thick line buys legibility at small sizes: in the four-across view the ink figure's pose and mood read before the kit's hatched one does, and the flat shirt reads as one colour where the hatching reads as texture. At full panel size the sketch has more life; the ink pack looks like a sticker.",
    "Keeping the face on model was the hard part. The kit places eyes, brows and mouth with fixed pixel offsets on a 56 px head; under a 5 px brow and a 5.5 px outline those features vanished, so the ink pack scales every feature with the head (one unit is a 56th of the radius) and gives surprised and excited eyes a white ring. Glasses had to drop to a 4 px line or they swallowed the eyes.",
    "Flat fills expose drawing order. The kit's hatching hides where an arm crosses the body; a flat fill does not, so the ink pack draws the far arm, then the body, then the near arm, and every limb is two strokes (ink under colour) to get an outline round a round-capped line.",
    "The contract held without a change to the look data: the same skin, hair, shirt, trousers, accessory and height fields drive both packs, all seven poses and ten moods are there, and { headX, headTop } comes back so a bubble would still find the head. The one difference is the signature (no Rough canvas), which is what a kit-level pack switch would have to hide behind a name."
   ]
  },
  {
   "slug": "pixel-pack",
   "title": "Pixel pack",
   "track": "characters",
   "question": "What survives of a cast when each character is a 16 by 24 pixel sprite generated from a few lines of text?",
   "summary": "The lab cast as 16 by 24 pixel sprites on a canvas, coloured from the cast's look fields, with a four-frame walk and three moods.",
   "kit": "v0.1.0",
   "libraries": [],
   "status": "exploring",
   "date": "2026-10-20",
   "learnt": [
    "Sixteen by twenty-four carries a skin, a hair shape, a shirt and a trouser colour, and three moods, because each needs only the eyes and a two-pixel mouth. The kit's other seven moods need brows, and there is no row for a brow between the hair and the eyes. Headphones read, because two accent-coloured blocks beside the head are unmistakable; the lanyard reads as a stripe with a card, which is enough; glasses were a dark bar across the eyes until the lenses got white pixels, which costs three rows of a nine-row face and pushes the eyes a pixel apart, so a character with glasses is a different face, not the same face with glasses.",
    "The walk is a front-view walk: one foot lifts, then the other. It reads as walking because the figure also moves, not because the legs convince. A side-view stride would need a second drawing of every character, and the kit's seven poses would each need their own frames, so the pose vocabulary did not survive the trip at all.",
    "A game engine could eat these as they are: every frame is a fixed 16 by 24 cell, the frames strip is already a sprite sheet, and KAPLAY or Phaser load a sheet by giving a frame size and a frame count. The text description is the format Bitsy and PICO-8 sprites use, so the cast could be edited in any of those. Status: not tried here; the lab vendors KAPLAY, so that is the next experiment.",
    "Only the look data crossed over. The drawing shares nothing with the kit, and the sprite needs an idle and a walk that the cast file does not know about. If the cast JSON is the contract between packs, a pack has to invent what the file does not say and the file must not mind."
   ]
  },
  {
   "slug": "room",
   "title": "Room (a game engine)",
   "track": "engines",
   "question": "What does a game engine give a storyboard's cast, what does it cost, and what would it take for a storyboard to play inside one?",
   "summary": "kaplay in a canvas: the lab cast baked into sprites from the kit's drawings, a player who walks, bumps into people for a line and opens a vault.",
   "kit": "v0.1.0",
   "libraries": [
    "kaplay-3001.0.19.js"
   ],
   "status": "exploring",
   "date": "2026-10-20",
   "learnt": [
    "An engine gives, for nothing, the three things a storyboard page has to fake: input (keys, touch and a gamepad through one API, with the canvas owning the keyboard so a page's fields are left alone), a camera (one call a frame and the room is wider than the screen), and collisions (bumping into Vex is one handler on a tag). The room took fewer lines than the walk cycle's rig. Status: exploring.",
    "It costs the DOM. Everything is pixels on a canvas: no text to select or search, no svg to inspect or export, and the kit's drawings only get in by being baked into bitmaps first (SVG serialised, loaded as an image, drawn to a canvas, handed over as a data URL). The bake is done once at load and is cheap, but a sprite is one pose at one size: a new mood or pose is another bake, and zooming the camera shows the pixels where the SVG would stay crisp.",
    "Rasterising through a canvas was needed, not a fallback: the engine's loader takes a URL and the page must not fetch anything from a third party, so the sprite is a data: URL made by the page, and that needs the canvas step. The SVG is written with explicit width and height attributes, so the image has a size to draw at; the page avoids the blank-image failure rather than testing it. The kit's fonts do not reach the engine either; the lines are drawn in the engine's own font.",
    "For a storyboard to play inside an engine it would need three things the data does not have yet: a room (where the floor is, where people stand, what blocks them), verbs on the props (the vault's open is a sprite swap here, written by hand) and the lines as reactions rather than a sequence. The storyboard's kinds of scene, with cast, props and says, map onto all three; what is missing is the geometry and the triggers, which is a new scene kind, not a change to the kit."
   ]
  },
  {
   "slug": "scrolly",
   "title": "Scrolly",
   "track": "layout",
   "question": "Can one sticky panel, redrawn and played as the text scrolls, tell a storyboard better than a deck does, and what should the text beside it say?",
   "summary": "A scrollytelling storyboard: a sticky panel redrawn and played as eight steps of text scroll into the middle of the window, with a progress bar and a panels-only mode.",
   "kit": "v0.1.0",
   "libraries": [],
   "status": "promising",
   "date": "2026-10-20",
   "learnt": [
    "Scroll paces a story by distance, a deck paces it by clicks. A step here is 62% of the window tall, so the reader sets the tempo with a thumb and can linger or race; the deck's play-on-arrival gives every panel the same beat. The cost is that a fast scroll passes a step before its strokes have finished drawing, which a deck never does. Status: works; the thing to try next is a shorter play when a step is passed quickly.",
    "Redraw per step is fast enough, measured. drawScene clears the svg and draws the whole scene again, seeded, and the readout under the panel times it: in the checker's Chromium the first draw took 45 to 65 ms (the cold run, with the fonts and Rough.js warming up) and every later step 4 to 15 ms, under one frame, with no flicker because the drawing happens before the browser paints. A jump from step 8 back to step 5 redrew 7 and 6 on the way at that cost, so one panel redrawn beats eight svg elements swapped.",
    "The text beside a panel should say who, why and what to look at, and never repeat a bubble. A first draft restated the bubbles and the reader read every line twice at two sizes. What the prose carries that the panel cannot: the character's intent (Oto means well), the reason behind the rule, and a pointer (watch Unit's face). The caption inside the panel is the panel's own and stays short.",
    "The kit's stroke draw-in did not start in Chromium 141 until this page nudged it. play() toggles a class on the panel and relies on a rule on path[pathLength] to draw the strokes; the browser did not restyle those paths for the class change, so the people and the bubbles arrived but every stroke was simply there. One inline change per path after play() makes the browser restyle them, and the draw-in runs (measured: 47 of 47 paths animating on the cover). The sequence experiment hit the same wall. Status: a bug to report against the kit's CSS, fixed by classing the paths instead of selecting them by attribute; and play() still wants a promise or an event for when the arrival ends, since it returns only a length in milliseconds."
   ]
  },
  {
   "slug": "things-with-faces",
   "title": "Things with faces",
   "track": "characters",
   "question": "Can a rule, a store or a boundary be a character in a storyboard rather than furniture?",
   "summary": "An inbox, a vault, a padlock, a server and a boundary wall, each with a face in the kit's ten moods and a reaction of its own, with Vex from the lab cast pushing the wall.",
   "kit": "v0.1.0",
   "libraries": [],
   "status": "exploring",
   "date": "2026-10-20",
   "learnt": [
    "A rule can be a character when it has a body that stands on the floor, a face, and one thing it does. The boundary wall became a character the moment it had an arm: the face says how it feels, the arm says what it will do, and the arm did more of the work. A wall with a face and no arm is a mural.",
    "Where the face sits decides whether it reads. On the tray front the inbox reads at once; the padlock's body is a face already; the server's eyes sat among its status lights and read as two more lights until they got white rings and brows; the vault's dial competes with its face, so the dial moved to a corner.",
    "A change reads better than a state. The inbox going from happy to worried to sad as the pile grows tells a story in a few clicks; the same worried face as a still is a worried tray. The shake and the arm, both CSS animations on the drawn group and stills under reduced motion, carried more than the brows did.",
    "The kit does not export its face. Brows, mouths and eyes are private to drawCharacter, so this page copies the two tables; the day the kit changes a mouth, these things drift off model. The thing to lift is a face(g, rc, mood, x, y, size, dir) export so a prop can borrow the cast's expressions."
   ]
  },
  {
   "slug": "walk-cycle",
   "title": "Walk cycle",
   "track": "motion",
   "question": "Can a stick-figure rig driven by a phase give a storyboard character a walk, a run and a jump, and still look like the kit?",
   "summary": "An 11-joint rig posed by parametric walk, run, jump and idle cycles, then the same bones dressed in Oto's colours.",
   "kit": "v0.1.0",
   "libraries": [],
   "status": "exploring",
   "date": "2026-10-20",
   "learnt": [
    "A rig gives you every in-between for free: the four gaits here are four small functions of a phase, and speed, stride and direction are numbers, where the kit's seven drawn poses are seven fixed pictures with nothing between them. The cost is that a rig only knows what its functions know: a pose that is not on a cycle (think, shrug, sit) still has to be authored.",
    "A walk reads as a walk from two positions, not from the whole cycle: the contact (both legs straight and apart, the body at its lowest, phase 0.25 and 0.75 here) and the passing (the swinging leg bent under a body at its highest, phase 0 and 0.5). Get those two right and the in-betweens can be plain sine waves.",
    "Three things break it: the feet slide if the distance travelled per cycle does not match the stride (fixed by deriving the distance from the thigh swing); a run with the same bob as a walk looks like a fast walk (a run needs a flight phase, a forward lean and bent arms); and Rough.js redrawn every frame boils even with a fixed seed, because the wobble is proportional to a geometry that changes each frame.",
    "The costume over the bones is thick strokes in the shirt and trousers colours plus a skin circle and the beanie, with flat fills rather than the kit's hachure; it reads as the same character at a glance. Lifting this into the kit would mean drawing a character from a joint list instead of fixed offsets, a new release of drawCharacter, not a patch. Status: exploring."
   ]
  }
 ]
}
