# Still One-paragraph description of what this module provides and who consumes it. ## Exports - `M.exampleFn(arg) -> result` — what it does and when to call it. - `M.exampleValue: type` — what value it carries. ## Usage Replace `<identity>` with the string `asset.create` returned — this module's source path with `/` written as `.` and each segment's type suffix dropped, the way a module at `/source/lib/thing.module` is `lib.thing` and one at `/source/kit.package/thing.module` is `kit.thing`. ```luau local M = require("<identity>") M.exampleFn("foo") ``` ## Notes - Anything callers need to know about THIS module: required runtime ordering, state ownership, side effects.

# KetylCore The core slice's own shared surface, and nobody else's. `Conductor` and `KetylPilot` are the two halves of the rules of THE EIGHTH KETYL, and this is where they agree about what the controls read, where the ketyl is, which way it faces and whether it may move. Other slices talk to core through the `Still` event bus, which is the contract the whole game shares. Nothing outside the core slice reads this module. ```lua local Core = require("game.KetylCore") ``` ## Why it exists at all Editing a component hot-reloads it, and a hot-reload re-executes the chunk: anything a component held in a file-scope local comes back at its default while the instance keeps running, and anything it subscribed to in `awake()` gets subscribed a second time. So the run's clocks and the registrations live here, and the components register plain functions that this module calls. Re-registering replaces; it never stacks. Editing **this** file is the other direction, and it behaves differently than the shape above suggests: the module table stays the same object, its functions are replaced, and every local behind them starts over — so the run's clocks, the body, and the record of who holds the controls all come back empty. The dependent components' `awake()` does **not** run again to notice. Each of them therefore watches for the one reading that says it happened — nobody holding the controls, or an empty handler table — and re-arms or re-installs from `update`. The same problem applies one level up — this file can be reloaded too, and the run that subscribed is the only one holding the unsubscriber. `modules.onUnload` is the answer: it hands the outgoing run a moment, with its own locals still in scope, to drop everything it put on the `Still` bus and on the controls, just before the next run replaces it. Within a run, `wire()` and `arm()` release before they register, so calling either twice is a replacement too. ## The surfaces | Surface | Written by | Read by | |---|---|---| | `Core.run` | Conductor | Conductor | | `Core.body` | KetylPilot | Conductor | | `Core.input` | the armed input map | KetylPilot | | `Core.press` | Conductor | the armed input map | | `Core.handlers` | Conductor | the bus forwarders | `Core.body.placeAt` is the one write that goes the other way: the Conductor asks for a teleport by putting a `{x, y, z}` there, and the pilot performs it and clears it. ## The numbers Everything about the still, the ketyl's speed, its charge and its wetness is in `Still.module` and read from there. What is here is the shape of the **run** — the parts of the loop that are rules rather than fiction, which no other slice needs to agree with: `INTRO_SECONDS`, `GROWTH_GRACE`, `ASCEND_RADIUS`, `ASCEND_TIME`, `PLATE_MARGIN`, `FACE_TURN`, the hover bob, `ENDING_LOCKOUT`, and the two warning thresholds. ## The rules, as functions `approach` · `hoverY(n)` · `clampToPlate(x, z)` · `riserDistance(x, z, n)` · `arrivalPoint(n)` · `dischargeFalloff(dist, cosAngle)` · `controllable(phase)` · `invulnerable(now)`. No state, no side effects — a test can call them without a running game. `dischargeFalloff` is the shape of a discharge's arc written once. Core does not apply it; the blennoma slice decides what was hit. It is here so that both answers come from one function rather than two that drift.