@maka/maka-cli 5.126.0 → 5.128.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/spots.d.ts

@@ -1,669 +0,0 @@
-import type { Room, IRoomSpot } from '../models/room.js';
-import type { Player } from '../models/player.js';
-import { Direction } from '../types/shared/direction-enum.js';
-import { GridCoord, ITerrainRegion } from './room-grid.js';
-/**
- * Intra-room locations ("at" spots -- player request: every room felt
- * like everything stood at your elbow; walking into the bar had both
- * NPCs on you instantly, and you could pick a lock from across the
- * room). A room MAY declare named spots (door, bar, booths...); actors,
- * items, and puzzles MAY be positioned at one.
- *
- * THE COMPAT RULE (sacred, two layers):
- * 1. A room with NO spots is one implicit whole-room spot -- every
- *    helper here short-circuits and behavior is exactly the pre-spots
- *    game. Old seeds never set spots.
- * 2. UNPOSITIONED = CIRCULATING: anything without an atSpot is
- *    "anywhere in the room" -- it reaches everything and everything
- *    reaches it, and it gets no cover. Companions, spirits, and
- *    un-migrated NPCs can never strand. Only explicitly positioned
- *    things gate.
- *
- * Spots are a MEAT-plane concept: a Matrix host has no barstools, and
- * astral space overlays the room whole -- off-meat actors read as
- * unpositioned.
- *
- * Every spot comparison in the game goes through these helpers -- no
- * call site rolls its own.
- */
-export declare function spotsActive(room: Room | undefined): boolean;
-/**
- * The IMPLICIT spot every spotted room has: the open floor. "move away"
- * stands you here -- deliberately at none of the named places (player
- * request: "I don't want to be at the door, bar, booths, or back
- * corner"). It is a REAL position, not the circulating compat state:
- * you don't reach the bar from out here, and an NPC who wants you
- * steps onto the open floor too -- that's where you both are. No cover,
- * always visible: standing apart has a price.
- */
-export declare const OPEN_FLOOR = "open floor";
-/** Fuzzy-resolves a typed name ("booth") to a declared spot ("booths"),
- * or "away"/"open floor"/"middle" to the implicit OPEN_FLOOR. */
-export declare function resolveSpot(room: Room | undefined, name: string): IRoomSpot | undefined;
-/**
- * The actor's validated position: undefined when the room isn't
- * spotted, the actor is off-meat, unpositioned, or names a spot the
- * room no longer has (stale writes read as circulating, never as a
- * phantom position).
- */
-export declare function spotOf(actor: Player): string | undefined;
-/** Whether two actors share a spot (callers already gate same-room). */
-export declare function sameSpot(a: Player, b: Player): boolean;
-/** Whether an actor can reach a positioned thing (item/puzzle/exit). */
-export declare function canReach(actor: Player, targetSpot: string | undefined): boolean;
-/**
- * ROOM GRIDS (spatial wave 2026-08-25): the spot-name-level wrappers
- * around utilities/room-grid.ts's coordinate primitives -- everything
- * ABOVE this line still only ever touches spot NAMES; nothing but
- * these three functions (and Room.ensureGrid itself) ever sees a
- * GridCoord. All three return undefined/0 when the room has no grid
- * (THE COMPAT RULE: a spotless room never synthesizes one) or the
- * named spot doesn't exist in it.
- */
-export declare function spotCell(room: Room, spotName: string): GridCoord | undefined;
-/** Every cell physically filled by furniture -- the full footprint of
- *  each named place (a bar runs several cells), minus the open floor
- *  (bare ground) and minus any OPEN doorway (a threshold you stand in,
- *  see openThresholds). Nobody stands here and movement goes around. */
-export declare function furnitureCells(room: Room): Set<string>;
-/** The ONE cell a doorway is reached from: directly opposite the door,
- *  one step in from its wall (player ruling 2026-08-25 -- "a south door
- *  requires you can move through the cell one unit north of it"). This
- *  is what makes a doorway a chokepoint worth holding. Undefined for
- *  up/down exits, which have no wall to stand off, and for an approach
- *  that would fall outside the room. */
-export declare function approachCellFor(room: Room, direction: Direction): GridCoord | undefined;
-/**
- * Who is standing in the way of this doorway -- in the threshold itself
- * or in its single approach cell. A body in either one holds the door
- * (the 2026-08-25 ruling): squeezing past is not on offer here the way
- * it is in open floor, because there is no second route to a doorway.
- *
- * `mover` never blocks themselves, and neither do their OWN companions:
- * a spirit that follows you at your heel gets seated beside you, which
- * would routinely park it on your approach cell and wall you into the
- * room you just walked into.
- */
-/**
- * A FIXTURE sitting in a doorway or on its single approach cell -- the
- * non-living half of doorwayBlocker (playtest 2026-08-25: "I shouldn't
- * be able to 'go' a direction if something is in the way of it").
- * Synthesis reserves those cells so this should never fire on a
- * generated room; it stays as the guard for hand-authored seeds, which
- * can declare a spot anywhere they like.
- */
-export declare function doorwayFurniture(room: Room, direction: Direction): string | undefined;
-/**
- * Who actually HOLDS the way -- someone with a reason to stop you.
- *
- * Originally this was every non-ally on the threshold, which made any
- * bystander who happened to drift onto the doorway cell into a brick
- * wall (playtest 2026-08-25: Mr. Vane, the runner's own meet contact,
- * parked in the down doorway and sealed the room. Jax -- under a
- * standing "follow" order -- could not obey it, improvised a grapple to
- * shift him, and trapped himself: holding someone forbids walking away,
- * so his next "go down" refused too. He read as disobedient; he was
- * cornered by this rule). A doorway is a chokepoint when someone is
- * CONTESTING it, not when someone is merely standing there.
- */
-export declare function doorwayBlocker(room: Room, direction: Direction, mover: Player): Player | undefined;
-/**
- * Move a non-hostile body off an exit so the way opens, returning their
- * name (or undefined if nobody needed to move / nowhere to put them).
- * The player ruling that drove this: "if I try to move to a location a
- * party member is, they should move aside."
- */
-export declare function yieldDoorway(room: Room, direction: Direction, mover: Player): string | undefined;
-export declare function seatingIn(room: Room): Map<string, GridCoord>;
-/**
- * One tactical step (player request 2026-08-25: "move south 2"). Walks
- * up to `count` cells in a cardinal direction from wherever the actor's
- * body actually is, stopping at the first square it cannot enter -- a
- * wall, furniture, uncleared terrain, or somebody standing there. No
- * squeezing: this is a deliberate step, so it stops rather than
- * shouldering through.
- *
- * Returns the cell reached and how many steps were actually taken, plus
- * what stopped it short. Nothing is mutated -- commands/move.ts commits
- * the result.
- */
-export declare function stepFrom(room: Room, mover: Player, direction: Direction, count: number): {
-    cell?: GridCoord;
-    taken: number;
-    blockedBy?: 'wall' | 'furniture' | 'terrain' | 'someone';
-    /** Who stopped it, when `blockedBy` is 'someone'. The caller needs the
-     *  name to decide whether the mover can SEE them -- a body still
-     *  blocks the square either way, but the sentence about it changes. */
-    blocker?: string;
-};
-/**
- * The named place a stepped-to cell counts as being "at" -- whichever
- * fixture the cell touches (its own footprint or any neighbour of it),
- * else the open floor. This is what keeps `atSpot` authoritative for
- * every interaction while the body stands on an arbitrary square:
- * step up beside the bar and you are AT the bar, step away and you are
- * on open ground.
- */
-export declare function spotForCell(room: Room, cell: GridCoord): string;
-/**
- * A cell `mover` could stand in at or beside `target` -- the general
- * form of seating, for walking to something that is not a named place.
- * Used by "move to <body>": the fallen keep a cell but no spot, and you
- * still need to be able to walk over and go through their pockets.
- */
-export declare function standingRoomNear(room: Room, target: GridCoord, mover: Player): GridCoord | undefined;
-/**
- * WHERE THIS ACTOR'S BODY IS -- the ONE answer to "where are they", and
- * the only one any surface may consult (2QpCcKFKCynk9jYoX).
- *
- * It used to refuse for anyone circulating: `spotOf(actor) === undefined
- * -> undefined`. seatingIn had already given those bodies a drift seat
- * so the minimap could DRAW them, and the comment there said plainly
- * that a derived seat was "a place to DRAW someone, never a position
- * they hold". That split is the defect the player rejected the first
- * fix over: "Mr. Vesper is NOT where I'm standing, and is not within
- * reach. If he's within reach, I should see him next to me in the room
- * map." The map drew him across the bar while every reach check
- * answered "right where you stand", because distance fell through to 0.
- *
- * The ruling: "NPCs, while need not have a location, need to have
- * coordinates. These coordinates govern distance to the Player. The
- * artificial 'exists in the entire room' is wrong."
- *
- * So the drift seat IS the position now. Having no named SPOT is not
- * the same as having no PLACE -- a man working a room is somewhere in
- * it at any moment, and that somewhere is what the map has been drawing
- * all along.
- *
- * This file already fixed the mirror image of this bug once (see
- * seatingIn's picket note, 9nMy3GdTuyKck2aDR): two representations of
- * position disagreeing, with the check reading the one the fiction does
- * not. The direction that has to win is the same one -- the grid agrees
- * with what the player can see.
- *
- * Still undefined off the meat plane or in a room with no grid: a
- * persona and an astral form genuinely hold no floor, and the compat
- * rule says a spotless room never synthesizes a grid.
- */
-export declare function actorCell(room: Room, actor: Player, seats?: Map<string, GridCoord>): GridCoord | undefined;
-/**
- * ADJACENT, in metres. The grid's cell is 2m (METERS_PER_CELL), so one
- * step -- orthogonal or diagonal -- is the finest "next to me" this
- * model can express; 2m orthogonally, ~2.83m corner to corner.
- *
- * NOT presented as a canon number, because canon does not give one for
- * bare melee range: the nearest hard figure is Interception at "one
- * meter (+1 meter per point of Reach)" (SR5 p.194), and the core melee
- * section was NOT among the retrieved excerpts, so claiming 1m as the
- * rule would be asserting something unverified. What is defensible is
- * that a cell is this engine's atom of position, and the player's own
- * words for the test are "next to me in the room map".
- */
-export declare const ADJACENT_METERS: number;
-/** Everything you have to walk AROUND rather than through: other
- *  people's bodies and the furniture itself. findPath treats these as a
- *  soft block (see its pass order) so they steer a route without ever
- *  making a destination unreachable. `mover` is always excluded -- you
- *  never block yourself. */
-export declare function occupiedCells(room: Room, mover?: Player): Set<string>;
-/**
- * WHO is standing in each blocked cell -- the same people occupiedCells
- * counts, but still named. Movement needs the name and not merely the
- * square: "someone's in the way" is only a true sentence if the player
- * can actually see the someone (z5RQFYA5yZjuwDSzT: "I'm getting a
- * 'somone's in the way' message, but no one is here on the map").
- *
- * Returns cell key -> actor name. Actor objects would be handier and are
- * deliberately not returned: this runs on every pathing pass, and the
- * one caller that narrates looks the body up once, where it narrates.
- */
-export declare function standingOccupants(room: Room, mover?: Player): Map<string, string>;
-/** The cell `mover` would end up in on arriving at `spotName` -- their
- *  seat around that fixture, with everyone else's seats already taken.
- *  This, not the fixture's anchor, is where movement actually paths to:
- *  the anchor is furniture now, and nobody stands inside the bar. */
-export declare function seatFor(room: Room, spotName: string, mover: Player): GridCoord | undefined;
-/** Straight-line meters between two actors' BODIES -- the distance
- *  combat should use, now that people stand beside their furniture
- *  rather than inside it. Falls back to their spots' own separation
- *  when either has no seat (circulating, or a gridless room). */
-export declare function actorDistanceMeters(room: Room, a: Player, b: Player): number;
-/** The walkable route between two spots, or undefined when terrain
- *  blocks every route (see move.ts / ensureAtSpot for the refusal).
- *  Purely geometric -- bodies and furniture are NOT considered, because
- *  the only thing that may hard-refuse a crossing is terrain; see
- *  routeForMove for the version movement actually walks. */
-export declare function pathBetweenSpots(room: Room, from: string, to: string): GridCoord[] | undefined;
-/**
- * The route a body actually walks: seat to seat, steering around other
- * people and around the furniture (player ruling 2026-08-25 -- "cannot
- * move through, only around"). Reports whether it had to SQUEEZE past
- * somebody, which move.ts narrates.
- *
- * Bodies and furniture are soft blocks by design (see findPath's pass
- * order): a crowded room slows you down and makes you go the long way,
- * but it can never strand you. Only terrain hard-refuses, and that
- * check stays in pathBetweenSpots where it always was.
- */
-export declare function routeForMove(room: Room, mover: Player, toSpot: string): {
-    path?: GridCoord[];
-    squeezed: boolean;
-};
-export declare function spotDistanceMeters(room: Room, from: string, to: string): number;
-/**
- * Is this actor actually IN cover right now?
- *
- * True only while they are still standing where they took it (see
- * Player.coverAtSpot). TAKE COVER is a Simple Action, SR5e p.166, and
- * the +2/+4 on the Defense Test (p.190) is the defender's for having
- * spent it -- so merely standing near a crate is not cover, and
- * stepping away from one ends it without anything having to notice.
- */
-export declare function isInCover(actor: Player): boolean;
-/** Take cover where this actor stands. Callers check availability
- *  first (see coverAvailableFor) -- this only records the choice. */
-export declare function takeCoverHere(actor: Player): void;
-/**
- * What cover this actor's own position offers, if any -- the tagged
- * rating of the spot they stand at. Terrain occluders between two
- * particular cells are a per-shot fact and belong to the exchange (see
- * combat-exchange.ts); this is the "is there anything here to get
- * behind at all" question TAKE COVER has to answer before it can be
- * spent.
- */
-export declare function coverAvailableFor(actor: Player): 'partial' | 'good' | undefined;
-/** Every place in this room that offers something to get behind --
- *  so a refusal can name where the cover actually is. */
-export declare function coverSpotsIn(room: Room): string[];
-/** Cover between two spots (see room-grid.ts coverBetween) -- honors a
- *  cover-tagged DEFENDER spot first (the same check combat-exchange.ts
- *  makes), falling back to a terrain occluder on the line between. */
-export declare function spotCoverBetween(room: Room, from: string, to: string): 'partial' | 'good' | undefined;
-/** How many z-levels the route between two spots climbs via a risky
- *  'climb' link (stairs/ladder never roll anything) -- undefined when
- *  the crossing never touches one. See move.ts's Athletics check. */
-export declare function spotClimbSteps(room: Room, from: string, to: string): number | undefined;
-/**
- * Re-seats the OPEN FLOOR on the emptiest ground in the room, and
- * returns whether it moved (playtest 2026-08-25: "'move away' is an
- * actual location" -- it was pinned to one synthesized cell near the
- * centroid, so peeling off always put you in the same square no matter
- * who was standing where). "Away" should mean AWAY: the cell that
- * maximises distance from the people you're stepping back from, then
- * from the room's fixtures.
- *
- * Scored lexicographically -- people first, furniture as the
- * tie-break -- over cells that exist, aren't sealed behind terrain,
- * and that `mover` can actually reach. Anyone ALREADY on the open
- * floor is excluded from the avoid-set: they're the ones this cell
- * belongs to, and counting them would have it flee itself.
- *
- * Callers must invoke this BEFORE setting `atSpot = OPEN_FLOOR`; the
- * grid is transient display/geometry state (never serialized), so a
- * reload simply re-derives the synthesized default -- see the
- * determinism contract in room-grid.ts.
- */
-export declare function reseatOpenFloor(room: Room, mover: Player): boolean;
-/** Which terrain region is sealing the route from `from` to `to`, and
- *  the Puzzle that clears it (for the bypass verb) -- undefined when
- *  the room has no grid, or (a synthesis edge case) a region blocks
- *  the path but its device can no longer be found. */
-export declare function blockingRegion(room: Room, from: string, to: string): {
-    region: ITerrainRegion;
-    device: import('../models/device.js').Device;
-} | undefined;
-/** One refusal voice for a terrain-blocked crossing -- always names
- *  the obstacle AND the verbs that actually work it. */
-/**
- * WHY THE WALK YOU ARE ABOUT TO ADVERTISE WOULD BE REFUSED -- or
- * undefined when it would not (2D6uZWqiWn9Mrhunc: "cannot move to steel
- * door, there is a wall around it").
- *
- * Every surface that says "it's over there, `move to <spot>`" decided
- * that with `canReach`, which is spot EQUALITY, while the walk itself is
- * gated by `pathBetweenSpots`, which is a ROUTE. Two notions of "can I
- * get there", computed by different code, with the ADVICE using the
- * weaker one -- so anything behind blocking terrain got a listing that
- * sent the player at the very thing sealing the way.
- *
- * 57f506db fixed that for the BARRIER listing in search.ts and left its
- * siblings: the item listings in take.ts, look.ts and search.ts ask the
- * same weak question about the same rooms. This is that fix, extracted,
- * so the remaining sites share it instead of each growing a fourth copy.
- *
- * THE PATHFIND COMES FIRST AND IS NOT OPTIONAL. `blockingRegion`
- * answers "would clearing this region open a path", never "is the way
- * shut" -- it names a region even when the route is already open. Every
- * caller has to gate it behind a failed `pathBetweenSpots`, and the
- * first cut of the original fix did not, which would have reported a
- * seal on a room you can walk straight across. Holding that ordering in
- * ONE place is most of why this function exists.
- *
- * Undefined means "no reason not to walk", which includes the cases
- * where the question cannot be asked at all: a circulating actor, a spot
- * that is not on the grid, a room with no grid. Those are not seals, and
- * reporting them as such would ground a player over a missing lookup.
- */
-export declare function sealedRouteTo(room: Room, actor: Player, target: string | undefined): string | undefined;
-/**
- * The first of `targets` the actor could actually walk to, or undefined
- * when every one of them is sealed off.
- *
- * The companion to sealedRouteTo, for the advice that has a CHOICE. A
- * refusal naming cover, a quiet spot to take a call at, a place to stand
- * -- each picks one out of a list, and each used to pick `[0]` without
- * asking whether the walk exists. Suggesting a reachable one is better
- * advice than explaining why the first is unreachable, and it is the
- * same question either way.
- */
-export declare function firstReachable(room: Room, actor: Player, targets: readonly string[]): string | undefined;
-export declare function terrainRefusal(region: ITerrainRegion, targetLabel: string, device?: import('../models/device.js').Device): string;
-/**
- * The same voice, for a LOCKED DOOR rather than blocking terrain
- * (blocker 2026-08-27, "the barrier isn't allowing me to
- * hack/pick/breach it"). `go` and `unlock` are where a player meets a
- * barrier before they know it is one, and both used to refuse without
- * naming a single route out -- go.ts said only "the door is locked",
- * unlock.ts only "you don't have the key". Neither mentioned that the
- * lock was workable, or how.
- *
- * Returns a TAIL to append (leading space), or '' when there is
- * genuinely nothing to name: a plain keyed door has no device, and
- * inventing a route would mislead worse than silence.
- */
-export declare function lockedRouteHint(room: Room, direction: Direction, door: {
-    heldBy?: {
-        device: string;
-        room: string;
-    };
-}): string;
-/**
- * WHAT KIND OF WAY THROUGH a spot's name describes, or undefined when
- * it isn't a way through at all (a bar, a workbench, the stalls).
- *
- * THE ONE DOORWAY PREDICATE (item A, 2026-08-27). There were two
- * separately-written copies of this regex -- here in entrySpotFor and
- * in Room.namedDoorwayFor -- free to drift apart, and neither knew the
- * distinction that actually matters: a "back door" is a LATERAL way
- * through and a "way down" is a VERTICAL one. Kind-blindness is what
- * let namedDoorwayFor bind a spot called "the back door" to a DOWN
- * exit, which put the basement's barrier at the back door (the player's
- * report) and, because vertical exits are centre-placed, simultaneously
- * put the back door in the middle of the room (the older report). One
- * defect, two bug reports.
- *
- * This is a PERMANENT component, not a migration shim. Generation is
- * moving toward binding every exit to a spot explicitly, but that data
- * is model-written: validation can make it right more often, never
- * always. And every scene seeded before that lands has nothing but
- * names, forever. So this is the honest floor under a seed that is
- * silent or lying, and it is the LAST resort -- an explicit
- * room.exitSpots binding always wins.
- *
- * Vertical is tested FIRST on purpose: "entry stairs" is a stair, not
- * an entry, and the shipped Chapel Crypt seed depends on reading it
- * that way.
- */
-export type DoorwayKind = 'lateral' | 'vertical';
-export declare function doorwayKindOf(spotName: string): DoorwayKind | undefined;
-/** The kind of way through a given direction NEEDS. */
-export declare function exitDoorwayKind(direction: Direction): DoorwayKind;
-/**
- * The spot an exit is reachable from. Seed-declared (room.exitSpots)
- * first; else a spot named like a doorway OF THE RIGHT KIND; else
- * undefined = the exit is usable from anywhere (compat).
- */
-export declare function exitSpot(room: Room, direction: Direction): string | undefined;
-/** Where an arrival through `direction` (the direction WALKED, from the
- * far side) stands: at this room's matching exit spot; else the room's
- * doorway-named spot; else its first spot (a positioned room always
- * positions the arriving player -- that's what makes gating bite). */
-/**
- * Where you physically land walking in through `arrivedFrom`: IN the
- * doorway you just came through (player ruling 2026-08-25 -- "when I
- * enter the night market from the east, I should arrive on the western
- * entrance"). The threshold is a standable cell now, so arrival no
- * longer has to be rounded to whichever named place happens to own that
- * exit -- Night Market's seed puts three of its exits "at the stalls",
- * which is right for LEAVING (that's the spot you must stand at to go)
- * but wrong for arriving, and used to materialise you ten metres inside
- * the room.
- *
- * Returns the exact cell plus the spot it counts as, or undefined when
- * the room has no grid, the direction has no doorway, or someone is
- * already standing in it -- all of which fall back to entrySpotFor.
- */
-export declare function arrivalAt(room: Room, arrivedFrom: Direction | undefined): {
-    cell: GridCoord;
-    spot: string;
-} | undefined;
-export declare function entrySpotFor(room: Room, arrivedFrom: Direction | undefined): string | undefined;
-/**
- * "the <place>", without doubling the article. Spot names come from
- * seeds, and a generated one may already carry its own determiner:
- * `at the ${name}` then renders "at the the back door" (item B,
- * 2026-08-27). Shipped seeds all use bare names ("door", "bar"), which
- * is why this only ever showed up in generated scenes.
- *
- * Returns the display form only -- the name itself is unchanged, since
- * that is what "move to <name>" has to match on.
- */
-export declare function theSpot(spotName: string, paint?: (s: string) => string): string;
-/** One refusal voice for every spot gate -- always names the cure. */
-export declare function spotRefusal(targetLabel: string, spotName: string): string;
-/**
- * Auto-move for object work (take/pick/hack/solve): out of combat you
- * just walk over -- one narration line, no ceremony (the user's ask was
- * that you CAN'T do it from across the room, not that you must type two
- * commands). Mid-exchange nobody strolls: refuse like go.ts does, and
- * the Phase-2 crossing machinery will make it cost instead.
- *
- * ROOM GRIDS (spatial wave 2026-08-25): checks the route FIRST -- an
- * uncleared barrier refuses the crossing even out of combat, always
- * naming the obstacle and the mechanism (utilities/room-grid.ts /
- * terrainRefusal). Rooms with no synthesized grid (still the common
- * case -- most spotted rooms carry no terrain hints) never pay for the
- * pathfind: spotDistanceMeters/pathBetweenSpots short-circuit to
- * "reachable" the same instant canReach already would have.
- */
-export declare function ensureAtSpot(actor: Player, targetSpot: string | undefined): {
-    line?: string;
-    refusal?: string;
-};
-/**
- * REACH FOR A WAY OUT -- the doorway twin of ensureAtSpot
- * (aJdfMkkSJ4CfY3ky3: "I'm able to open a door from more than 1 unit
- * away from it, I should have to stand right next to it").
- *
- * They were. exitSpot() answers undefined for an exit that no named
- * place owns, and `canReach(actor, undefined)` is TRUE by the compat
- * rule -- so an unbound door was workable from anywhere in the room.
- * Not a rare corner: 5 of the 28 exits across both shipped scenes are
- * unbound, including the locked east door of Krow's Den, which the
- * player could open from the far side of the desk.
- *
- * The reason the gate could not simply be closed is that a spot is the
- * only thing it knew how to gate ON, and these exits have none. But a
- * doorway has always had GEOMETRY: every room is matrixed
- * (Room.ensureGrid), so each exit owns a cell, and approachCellFor is
- * already "the ONE cell a doorway is reached from" -- the player's own
- * "one unit" made literal, ruled on 2026-08-25. So this gates on the
- * CELL when no spot is available, which needs no spot invented and
- * works in generated rooms as well as the five shipped ones.
- *
- * IT WALKS YOU, IT DOES NOT REFUSE YOU, and that is deliberate: it is
- * the rule ensureAtSpot already states -- "the user's ask was that you
- * CAN'T do it from across the room, not that you must type two
- * commands". A bound doorway has always strolled you over and said so;
- * an unbound one silently let you act at a distance. Now both cross,
- * both narrate, and both refuse mid-exchange.
- *
- * Both compat rules survive intact. A room with NO named places is
- * still ungated (rule 1), and an actor who is circulating still reaches
- * everything (rule 2) -- so no companion, spirit or un-migrated NPC can
- * strand on a doorway it was never positioned against.
- */
-export declare function ensureAtExit(actor: Player, direction: Direction): {
-    line?: string;
-    refusal?: string;
-};
-export { SPOT_COLOR } from './log-style.js';
-/**
- * Weaves the room's places into its PROSE: every spot name already in
- * the description gets the keyword color. When the full name isn't
- * there, the spot's HEAD NOUN is tried next -- generated prose
- * paraphrases ("stacked with crates" for the "stacked crates" spot),
- * and coloring the noun the author actually wrote beats bolting a list
- * onto good prose (playtest note: the "Also here:" tail didn't flow).
- * Only places the prose never touches at all get appended, as a
- * sentence in the game's voice.
- */
-export declare function highlightSpots(room: Room, text: string): string;
-export declare const ACTOR_COLOR = "green";
-/** The RAW cover threshold guarding a spot (p.135-136: Normal 2 for
- *  partial cover, Hidden 4 for good) -- 0 when nothing tucks there. */
-export declare function coverThreshold(room: Room, spotName: string | undefined): number;
-/**
- * PERCEPTION AT RANGE (SR5 p.135-136 Perception Test Modifiers,
- * RAG-verified): "object/sound not in immediate vicinity" -2, "object/
- * sound far away" -3. Canon names the bands but never puts meters on
- * them, so the metre cuts are OURS -- pinned to the scale the game
- * already speaks in, SR5 p.185's pistol brackets: short range 5 m is
- * "immediate vicinity", medium 20 m is where "far away" begins.
- *
- * This became load-bearing with the 2026-08-25 room resize: a `huge`
- * room is 32x22 m, so a stallholder clocking a runner the instant they
- * step through the far door was the room being too small, not the NPC
- * being sharp (playtest: "would Skitter even notice me?").
- */
-export declare const IMMEDIATE_VICINITY_M = 5;
-export declare const FAR_AWAY_M = 20;
-export declare function perceptionRangeModifier(meters: number): number;
-/**
- * The Perception threshold to pick someone out: p.136's "Normal" 2 for
- * a pedestrian, 4 for anyone in good cover -- and ZERO for a person
- * standing in the open inside `FAR_AWAY_M`, where seeing them is not a
- * test at all.
- *
- * That last clause is deliberate calibration, not laziness. Requiring a
- * test past `IMMEDIATE_VICINITY_M` was tried first and was far too
- * blind: it had the regulars in a 24x16 m bar failing to register
- * someone walking in twelve metres away. Canon's -2/-3 are about
- * resolving DETAIL at range, not about whether a human body registers
- * at all, so the test starts where "far away" does. A 32x22 m market
- * still hides you from the far stall; a bar does not.
- */
-export declare function noticeThreshold(room: Room, target: Player, meters: number): number;
-/**
- * Whether `observer` would register `target` at all right now, WITHOUT
- * rolling -- the passive read used by NPC reactions and by the room
- * map. Their Perception pool stands in for an average roll (pool/4,
- * SR5's own rule of thumb of one hit per four dice) so a sharp-eyed
- * fixer notices what a distracted teenager misses, and the range
- * modifier from p.135-136 applies.
- *
- * Deliberately NOT a dice roll: this fires on every movement event in
- * the room, and a random result would have NPCs blinking in and out of
- * awareness between one step and the next.
- */
-export declare function wouldNotice(observer: Player, target: Player): boolean;
-/**
- * HOW FAR A VOICE CARRIES. Canon has no rule for this (RAG-checked:
- * p.135-136 covers Perception modifiers, p.441 white-noise generators,
- * nothing on speech range), so these bands are a documented RULING
- * pinned to the same 5 m / 20 m scale as perception above.
- *
- * The point is that a big room should SOUND big: before the 2026-08-25
- * resize every cross-spot remark got one flat "(calling across the
- * room)" tag, which in a 32x22 m market read as a stallholder holding a
- * casual conversation at a dead bellow (playtest: "he's basically
- * screaming").
- */
-export type VoiceBand = 'conversation' | 'raised' | 'shout' | 'yell';
-export declare function voiceBandFor(meters: number): VoiceBand;
-/** The tag appended to speech that has to travel -- empty at
- *  conversational range, where it would just be noise. */
-export declare function voiceTag(band: VoiceBand): string;
-/** Records that `viewer` has picked `target` out of their cover here --
- *  a spot they keep (Room.revealedBy) so every later read, the room
- *  map included, knows they've been seen. */
-export declare function revealActor(room: Room, viewer: Player, target: Player): void;
-/** Everyone `viewer` has already picked out of cover in this room. */
-export declare function revealedTo(room: Room, viewer: Player): ReadonlySet<string>;
-/** Runs a Perception result against every covered occupant, banking
- *  whoever it beats. Called by the verbs that constitute LOOKING (look,
- *  search) so the room map reflects what the player has actually made
- *  out. Returns the newly-revealed actors, for callers that narrate. */
-export declare function revealWithPerception(room: Room, viewer: Player, hits: number): Player[];
-/**
- * Actors in `room` visible to `viewer` without a fresh roll: the viewer
- * first, then anyone perceivable who is either standing in the open or
- * has ALREADY been picked out of their cover (Room.revealedBy -- see
- * revealWithPerception). Shared by highlightActors (prose) and
- * utilities/room-view.ts (the room minimap). Coloring or drawing
- * someone still unspotted would hand over a presence the Perception
- * test is there to guard.
- */
-export declare function visibleActorsIn(room: Room, viewer: Player): Player[];
-/**
- * IS `target` HIDDEN FROM `viewer` RIGHT NOW -- the ONE answer to "who
- * is present here", shared by the prose (whoIsWhereLine) and the map
- * (visibleActorsIn -> room-view.ts).
- *
- * IT IS ONE FUNCTION BECAUSE IT WAS TWO (item S6b4TLQWq46RN5kGu: "an
- * NPC that I can see when I do 'look' is not there on the room map").
- * Both surfaces answered the same question and answered it differently:
- * the prose applied a COVER test only, while the map ran `wouldNotice`,
- * which is a DISTANCE test. Past FAR_AWAY_M even someone standing in
- * the open needs a passive threshold of 2 while the range modifier is
- * -3, so on a `huge` room that is unreachable for any ordinary runner
- * -- the far side of a dock was simply never drawn. `look` said "Dock
- * Guard at the rusted gate"; the map showed an empty yard.
- *
- * THE PROSE WAS RIGHT, and the map already carried half the evidence: a
- * crew exemption added when "a companion across a big room quietly
- * failed it and dropped off the map". That was this same bug, found
- * once and fixed for allies only, because the report was about allies.
- * The exemption survives here as the ally clause -- it is still true,
- * it was just never the whole rule.
- *
- * WHAT THIS DELIBERATELY IS NOT: `wouldNotice`. That function keeps the
- * distance model and keeps its caller (models/npc.ts -- whether an NPC
- * REACTS to something across the room, which is a different question
- * and genuinely range-dependent). Nothing here changes it.
- *
- * Nothing is leaked by aligning the two, which is the check that
- * matters when a fix makes a surface more permissive: the prose already
- * named every non-cover occupant at any range, so the map is catching
- * up to what the player was being told, not learning something new.
- */
-export declare function concealedFrom(room: Room, viewer: Player, target: Player): boolean;
-/**
- * Colors the names of PRESENT, OBVIOUS people in a room's prose (player
- * request: places got the keyword treatment; actual NPCs deserve one
- * too). Only actors standing in the open are painted: coloring someone
- * tucked behind cover would confirm a presence the Perception check is
- * supposed to guard -- if stale prose names a hidden watcher, the text
- * stays flat and gives nothing away. Tries the full name, then its
- * distinctive words ("Krow" for "Mr. Krow").
- */
-export declare function highlightActors(room: Room, text: string, viewer: Player): string;
-/**
- * The compact who-stands-where line ('look' reads "You at the door,
- * Patch at the bar, Old Cray at the booths (cover)"): OCCUPIED places
- * only, viewer first, co-occupants grouped, circulating actors trailing.
- *
- * Casing the room is a PERCEPTION check (player ruling): pass the
- * viewer's Observe-in-Detail hits and occupants tucked at cover-tagged
- * spots need the RAW thresholds (p.135-136: Normal 2 for partial cover,
- * Hidden 4 for good cover) or they're silently omitted -- the booth ate
- * them. People in the open, at YOUR spot, or circulating are simply
- * seen, no dice (a pedestrian in plain view isn't a test). Omit `hits`
- * for the all-seeing form (NPC prompts -- residents know their room).
- */
-export declare function whoIsWhereLine(room: Room, viewer: Player, hits?: number): string;
-/**
- * The "who stands where" lines for the bare "move" list and NPC prompts:
- *   door (you), bar -- Mama Wu, booths (cover)
- */
-export declare function describeSpotRoster(room: Room, viewer?: Player): string[];