@maka/maka-cli 5.65.2 → 5.67.0

package/bundle/typescript/src/commands/game/sideQuest/factories/repro-scene.js

@@ -0,0 +1,320 @@
+import { Direction } from '../types/shared/direction-enum.js';
+import { ARCHETYPES, getArchetype } from '../archetypes.js';
+/**
+ * BUILDING THE BENCH A REVIEW ITEM SHIPS WITH.
+ *
+ * Two rooms and one sealed door between them. That is the whole scene,
+ * on purpose: a repro is a bench, not a run, and every room you have to
+ * walk through to reach the thing under test is a room the reproduction
+ * can go wrong in.
+ *
+ * THIS FILE OWNS THE INVARIANTS, and that is the reason it exists
+ * rather than the specs carrying raw seed JSON. The author of a repro
+ * states INTENT -- "a guard in the doorway", "a keypad sealing north" --
+ * and everything that intent implies is derived here, once, for every
+ * repro that will ever be written.
+ *
+ * The invariant that motivated the design: an NPC marked `guarding`
+ * whose startSpot is not the sealed exit's spot. Nothing throws.
+ * `holdsGround` is simply never consulted, because doorwayOccupants
+ * reads the exit cell and the guard is not standing in it. The scene
+ * builds, the walkthrough passes, and the repro demonstrates the
+ * opposite of what it claims -- a check whose two sides fail together
+ * cannot see the failure, which is the dominant defect shape in this
+ * codebase's history. An author cannot make that mistake here, because
+ * an author never supplies the spot.
+ *
+ * The other invariants are refusals rather than derivations, and they
+ * refuse LOUDLY rather than degrading. A repro that silently does less
+ * than it says is the failure mode this whole feature is built against,
+ * so "drop the field and carry on" -- which is what the runtime does
+ * with a code on a lock -- is exactly the wrong behaviour here.
+ */
+/** The room the device stands in, which is also the room that declares
+ *  the exit it seals. */
+export const REPRO_BARRIER_ROOM = 'The Approach';
+/** Through the door. */
+export const REPRO_FAR_ROOM = 'The Far Side';
+/** The one spot that matters, and the one an author never has to name.
+ *  Both rooms have it: a doorway has two sides, and a guard posted on
+ *  the far side stands in their own. */
+export const REPRO_DOORWAY_SPOT = 'doorway';
+/**
+ * Somewhere to stand that is NOT the doorway, so "move to the door" is
+ * a real move with a real before-state. Without it the runner starts in
+ * the doorway and the whole class of "I walked onto the guard's cell"
+ * items cannot be reproduced at all.
+ *
+ * NOT called "open floor", which was the first name and was wrong for a
+ * reason worth recording: "open floor" is the ENGINE's phrase for
+ * having no named spot at all (see move.ts -- "You peel off to the open
+ * floor"). Naming a real spot that made a positioned NPC render as
+ * "Grier at the open floor, Grier on the open floor" -- one clause from
+ * the spot, one from the generic fallback, reading exactly like a
+ * duplicate-render bug. Every reviewer sent to a bench would have filed
+ * it. A fixture must not borrow the engine's words for "none".
+ */
+export const REPRO_FLOOR_SPOT = 'back wall';
+const DEFAULT_DEVICE_NAME = {
+    lock: 'Maglock',
+    panel: 'Keypad',
+    ward: 'Chalk Ward',
+};
+const DEFAULT_DEVICE_DESCRIPTION = {
+    lock: 'A heavy maglock, seated in the frame and holding the door shut.',
+    panel: 'A keypad on a short steel stalk, its display waiting for a code.',
+    ward: 'A ward drawn in chalk and old ash across the whole doorway, humming against your teeth.',
+};
+const OPPOSITE = {
+    [Direction.NORTH]: Direction.SOUTH,
+    [Direction.SOUTH]: Direction.NORTH,
+    [Direction.EAST]: Direction.WEST,
+    [Direction.WEST]: Direction.EAST,
+    [Direction.UP]: Direction.DOWN,
+    [Direction.DOWN]: Direction.UP,
+};
+/** Archetypes that can work a ward. `dispel` needs the Art; nothing
+ *  else in the game does. */
+const AWAKENED = new Set(['Adept', 'Combat Mage', 'Street Shaman']);
+/** Bounds. A repro is a bench: more than this and it is a scene, and a
+ *  scene is a place a reproduction gets lost in. */
+const MAX_NPCS = 4;
+const MAX_ITEMS = 6;
+/** A fixture that cannot be built into an honest bench. Thrown, never
+ *  swallowed -- the caller turns it into a sentence for whoever wrote
+ *  the spec. */
+export class ReproFixtureError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ReproFixtureError';
+    }
+}
+function roomFor(side) {
+    return side === 'far' ? REPRO_FAR_ROOM : REPRO_BARRIER_ROOM;
+}
+/** A guard who is not in the doorway guards nothing, so `guarding`
+ *  implies `atDoorway` rather than sitting beside it as a second flag
+ *  the two could disagree about. */
+function standsInDoorway(npc) {
+    return npc.guarding === true || npc.atDoorway === true;
+}
+export function buildReproScene(fixture) {
+    const warnings = [];
+    // ARCHETYPE. getArchetype falls back to ARCHETYPES[0] on a name it
+    // does not know, which is right for a launcher menu and wrong here:
+    // a ward repro silently handed a mundane Runner is a repro that
+    // cannot be run, and it would look like the fix had failed.
+    const archetypeName = fixture.archetype ?? 'Covert Ops';
+    if (!ARCHETYPES.some(a => a.name === archetypeName)) {
+        throw new ReproFixtureError(`No archetype called "${archetypeName}". One of: ${ARCHETYPES.map(a => a.name).join(', ')}.`);
+    }
+    const npcs = fixture.npcs ?? [];
+    const items = fixture.items ?? [];
+    if (npcs.length > MAX_NPCS) {
+        throw new ReproFixtureError(`A repro carries at most ${MAX_NPCS} NPCs; this one has ${npcs.length}.`);
+    }
+    if (items.length > MAX_ITEMS) {
+        throw new ReproFixtureError(`A repro carries at most ${MAX_ITEMS} items; this one has ${items.length}.`);
+    }
+    const duplicateNpc = npcs.find((n, i) => npcs.findIndex(o => o.name === n.name) !== i);
+    if (duplicateNpc) {
+        throw new ReproFixtureError(`Two NPCs are both called "${duplicateNpc.name}" -- a name has to pick one body out.`);
+    }
+    const barrier = fixture.barrier;
+    const direction = barrier?.sealsExit ?? Direction.NORTH;
+    const startSide = fixture.start ?? 'barrier';
+    const startRoom = roomFor(startSide);
+    let device;
+    if (barrier) {
+        // INVARIANT 1: a code belongs to a panel and nowhere else. The
+        // Device constructor DROPS it on a lock or a ward, silently and
+        // correctly -- that is the runtime honouring "you can't talk at a
+        // mechanical lock". Inheriting that drop here would produce a bench
+        // whose stated credential does nothing, and the reviewer would read
+        // the refusal as the bug still being present.
+        if (barrier.code && barrier.kind !== 'panel') {
+            throw new ReproFixtureError(`A ${barrier.kind} has no code -- only a panel does. Give it a keyItem, or let it be picked or dispelled.`);
+        }
+        // A panel with no code cannot be opened the way a panel opens.
+        if (barrier.kind === 'panel' && !barrier.code && !barrier.keyItem && !barrier.open) {
+            warnings.push('This panel has neither a code nor a key, so the only way through it is force.');
+        }
+        if (barrier.kind === 'ward' && !AWAKENED.has(archetypeName)) {
+            warnings.push(`A ward answers to the Art, and ${archetypeName} is mundane -- fine if the refusal is the point, otherwise use Combat Mage.`);
+        }
+        device = {
+            name: barrier.name ?? DEFAULT_DEVICE_NAME[barrier.kind],
+            description: DEFAULT_DEVICE_DESCRIPTION[barrier.kind],
+            kind: barrier.kind,
+            code: barrier.code,
+            keyItem: barrier.keyItem,
+            // INVARIANT 2: the device stands AT the doorway it seals, so
+            // reaching it is reaching the door. bypass-command resolves the
+            // spot as exitSpot(room, opensExit) ?? atSpot, and a device
+            // sitting at neither is a device you cannot walk up to.
+            atSpot: REPRO_DOORWAY_SPOT,
+            // INVARIANT 3: naming the exit is what locks the door.
+            // scene-factory only LOGS when a device names something that is
+            // not a door, which on a bench means an unsealed doorway and a
+            // reviewer concluding the barrier never worked.
+            opensExit: direction,
+            // The walkthrough test caught this being dropped, which is the
+            // point of having one: `open: true` was accepted here and went
+            // nowhere, because the seed type had no such field. A fixture
+            // that quietly does less than it says is the exact failure this
+            // whole feature exists to prevent -- so the field was added to
+            // IDeviceSeedJson rather than the intent silently discarded.
+            open: barrier.open === true,
+        };
+    }
+    const spots = [
+        { name: REPRO_DOORWAY_SPOT },
+        { name: REPRO_FLOOR_SPOT },
+    ];
+    // THE BARRIER IS NAMED IN THE PROSE, and where it stands, and which
+    // way the door runs.
+    //
+    // A device is only surfaced by `search`, which is right for a real
+    // scene -- finding things is play. On a bench it is a trap: the whole
+    // promise is "you start standing at the thing", and the first player
+    // through one reported exactly that ("There is no location for the
+    // door, so I cannot get to it"). They looked, saw two spots and no
+    // door, and concluded the fixture was broken. Nothing here should
+    // have to be discovered.
+    const barrierRoom = {
+        name: REPRO_BARRIER_ROOM,
+        description: barrier
+            ? `A short concrete run ending at one door, ${direction} of you. `
+                + `${device.name} is fixed beside the doorway${barrier.open ? ', standing open' : ', holding it shut'}. `
+                + `There is nothing else here, which is the point -- whatever is wrong is wrong at that door.`
+            : `A short concrete run with a door ${direction} of you and nothing else in it.`,
+        roomType: 'Street',
+        size: 'medium',
+        spots,
+        isStartRoom: startSide === 'barrier',
+        exits: [{ direction, targetRoom: REPRO_FAR_ROOM, atSpot: REPRO_DOORWAY_SPOT }],
+        devices: device ? [device] : undefined,
+    };
+    const farRoom = {
+        name: REPRO_FAR_ROOM,
+        description: `The other side of the door, which lies ${OPPOSITE[direction]} of you`
+            + `${barrier ? ` and is held from the far side by ${device.name}` : ''}. Bare, and no further out.`,
+        roomType: 'Street',
+        size: 'medium',
+        spots,
+        isStartRoom: startSide === 'far',
+        // INVARIANT 3, other half: a door has two sides. Without the return
+        // exit the far room is a one-way pocket, and "go back and try it
+        // again" -- which is most of what reviewing a fix consists of --
+        // would not work.
+        exits: [{ direction: OPPOSITE[direction], targetRoom: REPRO_BARRIER_ROOM, atSpot: REPRO_DOORWAY_SPOT }],
+    };
+    const npcSeeds = npcs.map(npc => {
+        const side = npc.side ?? 'barrier';
+        const inDoorway = standsInDoorway(npc);
+        return {
+            description: npc.concept,
+            dialogue: [],
+            player: {
+                name: npc.name,
+                startLocation: roomFor(side),
+                // THE INVARIANT THIS FILE EXISTS FOR. Derived from the
+                // direction the barrier seals, never supplied -- a guarding NPC
+                // standing anywhere else holds nothing, silently, and the
+                // walkthrough would still pass.
+                startSpot: inDoorway ? REPRO_DOORWAY_SPOT : REPRO_FLOOR_SPOT,
+                guarding: npc.guarding === true,
+                lifestyleChoices: [],
+                combat: {
+                    body: 4, agility: 4, reaction: 4, combatSkill: 3, strength: 4,
+                    willpower: 3, logic: 3, intuition: 3, charisma: 3, edge: 2,
+                    skills: { unarmed: 3, perception: 3, negotiation: 3 },
+                },
+            },
+        };
+    });
+    const itemSeeds = items.map(it => ({
+        name: it.name,
+        description: it.description,
+        details: it.details,
+        size: 'Tiny',
+        category: 'Document',
+        shape: 'Rectangle',
+        color: 'Gray',
+        texture: 'Plain',
+        rating: 'Common',
+        weight: 0.1,
+        room: roomFor(it.side ?? 'barrier'),
+        atSpot: REPRO_FLOOR_SPOT,
+    }));
+    // INVARIANT 4: the key is on the side the runner starts on. A key
+    // behind the door it opens is a bench nobody can work, and it reads
+    // as the fix having failed rather than the fixture being wrong.
+    if (barrier?.keyItem) {
+        itemSeeds.push({
+            name: barrier.keyItem,
+            description: `The thing that opens the ${device?.name ?? 'door'}.`,
+            size: 'Tiny',
+            category: 'Key',
+            shape: 'Rectangle',
+            color: 'Steel',
+            texture: 'Milled',
+            rating: 'Common',
+            weight: 0.1,
+            room: startRoom,
+            atSpot: REPRO_FLOOR_SPOT,
+        });
+    }
+    if (barrier && !barrier.open && startSide === 'far') {
+        warnings.push(`The runner starts on the far side, so the ${device?.name} is through a shut door and cannot be worked from there -- right for testing what someone SAYS about the door, wrong for testing the door.`);
+    }
+    const seed = {
+        name: 'Repro Bench',
+        story: fixture.premise
+            ?? 'A bench, not a job. One door, whatever is standing at it, and nothing else to be distracted by.',
+        currency: { type: 'nuyen', authorityRoomTags: [] },
+        residenceTiers: ['Street', 'Squatter', 'Low'],
+        rooms: [barrierRoom, farRoom],
+        npcs: npcSeeds,
+        items: itemSeeds,
+        puzzles: [],
+        player: {
+            name: 'Testbed',
+            startLocation: startRoom,
+            // NO RESIDENCE. Copied from paritySeed originally, where it is
+            // right -- that fixture models a real run. A bench models nothing
+            // and nobody lives in it; declaring a home here only invites the
+            // lifestyle machinery to have opinions about a two-room scene.
+            lifestyleChoices: [],
+            startingItems: [],
+        },
+        // NO winCondition AND NO client, deliberately. A bench cannot be
+        // won, because there is nothing to win -- adding a payout would put
+        // a wrap-up, a settlement and an offer of more work in the way of a
+        // reviewer who came to look at one door. scene1 already proves a
+        // scene boots without a client.
+    };
+    return {
+        seed,
+        names: {
+            device: device?.name,
+            npcs: npcs.map(n => n.name),
+            direction,
+            barrierRoom: REPRO_BARRIER_ROOM,
+            farRoom: REPRO_FAR_ROOM,
+            startRoom,
+        },
+        warnings,
+    };
+}
+/** The archetype a fixture asks for, resolved. Separate from the build
+ *  because the launcher hands the NAME to the game (which rolls the
+ *  character itself) while the headless walkthrough needs the spread to
+ *  make a save out of. */
+export function reproArchetypeName(fixture) {
+    return fixture.archetype ?? 'Covert Ops';
+}
+export function reproArchetype(fixture) {
+    return getArchetype(reproArchetypeName(fixture));
+}
+//# sourceMappingURL=repro-scene.js.map

package/bundle/typescript/src/commands/game/sideQuest/factories/repro-scene.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repro-scene.js","sourceRoot":"","sources":["../../../../../../../src/commands/game/sideQuest/factories/repro-scene.ts"],"names":[],"mappings":"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"}

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-chunks.d.ts

@@ -328,6 +328,42 @@ export declare function resolveSpotName(declared: string, spotNames: string[]):
  * type.
  */
 export declare function ensureCredentialKindAgrees(details: ISceneDetails): string[];
+/**
+ * RESOLVE A NAME ONE LIST WROTE AGAINST THE LIST THAT OWNS IT.
+ *
+ * The skeleton cross-references by NAME in two places, and both are
+ * written by the model in different passes: an exit names the `device`
+ * that holds it, and an exit names the `guard` who stands in it. Both
+ * were then matched by exact string equality against devices[].name and
+ * npcs[].name -- and a near-miss produced no error, no warning, and a
+ * scene that validated perfectly while meaning nothing:
+ *
+ *   exit device "Keypad" vs devices[] "Door Keypad"
+ *     -> the device gets no opensExit
+ *     -> scene-factory never locks the door
+ *     -> "there is nothing this keypad locks, the door is open"
+ *
+ *   exit guard "Wraith" vs npcs[] "Wraith Kovac"
+ *     -> the NPC never gets `guarding`
+ *     -> holdsGround sees a bystander, yieldDoorway moves them aside
+ *     -> "I was able to just, push Wraith away"
+ *
+ * Two player-visible mechanics, one shape: a reference validated for
+ * STRUCTURE (a string is present) and never for MEANING (it names
+ * something that exists).
+ *
+ * REPAIR, not rejection -- the pattern this file already uses for a
+ * missing clue phrase and a guarded exit with no spot. Failing the
+ * draft costs a 6,000-token regeneration to fix one word, and a warning
+ * alone leaves the player-visible wrong in place.
+ *
+ * DELIBERATELY CONSERVATIVE. Exact, then trimmed/case-insensitive, then
+ * a UNIQUE substring either way. No typo tolerance and no nearest
+ * guess: binding a door to the wrong device is worse than leaving it
+ * unbound, because the unbound case at least logs. Anything that does
+ * not resolve returns undefined and says so.
+ */
+export declare function resolveNamedRef(ref: string, candidates: string[], what: string): string | undefined;
 export declare function assembleScene(skeleton: ISceneSkeleton, details: ISceneDetails, playerName: string): ISceneSeedJson;
 export type RepairTarget = 'rooms' | 'npcs' | 'devices' | 'items' | 'skeleton';
 /**

package/bundle/typescript/src/commands/game/sideQuest/factories/scene-chunks.js

@@ -1174,6 +1174,38 @@ function resolveDirectionCollisions(skeleton) {
  */
 export function normalizeSkeleton(skeleton) {
     const notes = [];
+    // WHO THE CLIENT IS, before anything counts them.
+    //
+    // NOT a missing guard -- an audit of the four names the model writes
+    // about other lists (2026-08-28) found all four checked: heldBy,
+    // winCondition.toNpc and .item fail in validateSkeleton below, and
+    // `client` fails in validateClient. The gap is narrower and it is
+    // about COST and ORDER.
+    //
+    // COST: validateClient REJECTS an unresolvable client, so a one-word
+    // near miss -- "Mr. Osprey" against a roster saying "Osprey" -- burns
+    // a full regeneration to fix a name the skeleton already contains.
+    // Every other name reference gained a repair on 2026-08-27; this one
+    // did not, so it is the only near miss still paying full price.
+    //
+    // ORDER: the opposition floor counts hostiles as
+    // `npcs.filter(n => n.name !== skeleton.client)` in validateSkeleton,
+    // which runs BEFORE validateClient ever sees the assembled scene. So
+    // an unrepaired near miss counts the CLIENT as a hostile and skews
+    // the difficulty floor by one -- silently, and in a check whose whole
+    // job is to notice an under-populated cast.
+    //
+    // Repairing here fixes both: the count is right, and a resolvable
+    // name never reaches the rejection. What genuinely matches nothing
+    // still falls to validateClient, which owns that verdict and words
+    // it better than a duplicate here would.
+    if (skeleton.client) {
+        const canonicalClient = resolveNamedRef(skeleton.client, (skeleton.npcs ?? []).map(n => n.name), 'the scene-level "client"');
+        if (canonicalClient && canonicalClient !== skeleton.client) {
+            notes.push(`client "${skeleton.client}" renamed to "${canonicalClient}" to match the roster.`);
+            skeleton.client = canonicalClient;
+        }
+    }
     // Topology before anything that reasons about topology: freeStranded-
     // Rooms, clue placement and the curb all walk this graph, and they
     // should walk the one the ENGINE will actually build.
@@ -1558,6 +1590,66 @@ export function ensureCredentialKindAgrees(details) {
     }
     return notes;
 }
+/**
+ * RESOLVE A NAME ONE LIST WROTE AGAINST THE LIST THAT OWNS IT.
+ *
+ * The skeleton cross-references by NAME in two places, and both are
+ * written by the model in different passes: an exit names the `device`
+ * that holds it, and an exit names the `guard` who stands in it. Both
+ * were then matched by exact string equality against devices[].name and
+ * npcs[].name -- and a near-miss produced no error, no warning, and a
+ * scene that validated perfectly while meaning nothing:
+ *
+ *   exit device "Keypad" vs devices[] "Door Keypad"
+ *     -> the device gets no opensExit
+ *     -> scene-factory never locks the door
+ *     -> "there is nothing this keypad locks, the door is open"
+ *
+ *   exit guard "Wraith" vs npcs[] "Wraith Kovac"
+ *     -> the NPC never gets `guarding`
+ *     -> holdsGround sees a bystander, yieldDoorway moves them aside
+ *     -> "I was able to just, push Wraith away"
+ *
+ * Two player-visible mechanics, one shape: a reference validated for
+ * STRUCTURE (a string is present) and never for MEANING (it names
+ * something that exists).
+ *
+ * REPAIR, not rejection -- the pattern this file already uses for a
+ * missing clue phrase and a guarded exit with no spot. Failing the
+ * draft costs a 6,000-token regeneration to fix one word, and a warning
+ * alone leaves the player-visible wrong in place.
+ *
+ * DELIBERATELY CONSERVATIVE. Exact, then trimmed/case-insensitive, then
+ * a UNIQUE substring either way. No typo tolerance and no nearest
+ * guess: binding a door to the wrong device is worse than leaving it
+ * unbound, because the unbound case at least logs. Anything that does
+ * not resolve returns undefined and says so.
+ */
+export function resolveNamedRef(ref, candidates, what) {
+    const want = ref.trim().toLowerCase();
+    if (!want)
+        return undefined;
+    const exact = candidates.find(c => c === ref);
+    if (exact)
+        return exact;
+    const loose = candidates.filter(c => c.trim().toLowerCase() === want);
+    if (loose.length === 1)
+        return loose[0];
+    const partial = candidates.filter(c => {
+        const n = c.trim().toLowerCase();
+        return n.includes(want) || want.includes(n);
+    });
+    if (partial.length === 1)
+        return partial[0];
+    // Unresolvable, or ambiguous between two candidates. Say so loudly --
+    // this is the line that would have turned two evenings of "pretty
+    // poor" into one grep.
+    try {
+        Logger.getInstance().write(`assembleScene: ${what} names "${ref}", which matches ${partial.length === 0 ? 'nothing' : `${partial.length} things`} in [${candidates.join(', ')}] -- the reference is dropped and the mechanic will not fire.`);
+    }
+    catch { /* no session: the note is a nicety, not a contract */ }
+    return undefined;
+}
 export function assembleScene(skeleton, details, playerName) {
     // The answer has to be legible before anything is assembled from it.
     ensureClueDetails(skeleton, details);
@@ -1754,7 +1846,18 @@ export function assembleScene(skeleton, details, playerName) {
                 }
                 catch { /* no session: the note is a nicety, not a contract */ }
             }
-            guardPost.set(named, { room: room.name, spot: e.atSpot });
+            // CANONICALISE, exactly as heldExit does above and for the same
+            // reason. `guardPost` is keyed by the exit's guard string and
+            // read back by the NPC's own name, so an exit naming "Wraith"
+            // while the roster says "Wraith Kovac" posted a guard nobody
+            // matched: `guarding` never got set, holdsGround saw an ordinary
+            // bystander, and yieldDoorway politely moved them aside.
+            // Reported verbatim: "I was able to just, push Wraith away by
+            // moving to the vault door."
+            const canonicalGuard = resolveNamedRef(named, skeleton.npcs.map(n => n.name), `guard on ${room.name}'s ${e.direction} exit`);
+            if (!canonicalGuard)
+                continue;
+            guardPost.set(canonicalGuard, { room: room.name, spot: e.atSpot });
         }
     }
     const npcs = skeleton.npcs.map(npc => {
@@ -1830,8 +1933,18 @@ export function assembleScene(skeleton, details, playerName) {
     const heldExit = new Map();
     for (const room of skeleton.rooms ?? []) {
         for (const e of room.exits ?? []) {
-            if (e.device)
-                heldExit.set(e.device, e.direction);
+            if (!e.device)
+                continue;
+            // CANONICALISE THE REFERENCE, or the door never locks. See
+            // resolveNamedRef: an exit saying device "Keypad" while devices[]
+            // calls it "Door Keypad" used to produce a keypad with no
+            // opensExit, and scene-factory locks a door FROM its device's
+            // opensExit -- so the player met a keypad beside a door standing
+            // open. Reported verbatim: "there is nothing this keypad locks,
+            // the door is open."
+            const canonical = resolveNamedRef(e.device, (skeleton.devices ?? []).map(d => d.name), `device on ${room.name}'s ${e.direction} exit`);
+            if (canonical)
+                heldExit.set(canonical, e.direction);
         }
     }
     const devices = (skeleton.devices ?? []).map(device => {