@maka/maka-cli 5.66.0 → 5.68.0

package/bundle/typescript/src/commands/game/sideQuest/resonance-actions.d.ts

@@ -0,0 +1,108 @@
+/**
+ * SR5e RESONANCE ACTIONS (core p.250) -- the technomancer's own action
+ * list, and the Resonance-side counterpart to the Matrix actions every
+ * other decker shares.
+ *
+ * WHY THIS IS A TABLE AND NOT SEVEN STRINGS IN SEVEN FILES.
+ *
+ * Backlog item SoopwuTFBwayCGhM9 ("check page 250 for resonance
+ * actions, right now we have several missing") could only be ANSWERED
+ * by laying the book's list beside the game's verbs -- and once that
+ * comparison exists, leaving it in a commit message means the next
+ * person re-derives it. So the comparison lives here, in the `verb`
+ * field, where it is machine-checkable rather than remembered.
+ *
+ * The audit that produced it, in one line each:
+ *   present  -- Compile, Decompile, Register, Thread (already built)
+ *   present  -- COMMAND SPRITE, via the generic `order` verb. This one
+ *               nearly got filed as missing: order.ts picks out of
+ *               `game.companions` with no kind filter, so it has always
+ *               reached sprites. A "missing" feature that already
+ *               exists gets built twice and the second one wins quietly.
+ *   built    -- KILL COMPLEX FORM, added as `unravel` against this
+ *               audit (see unravel.ts).
+ *   built    -- CALL/DISMISS SPRITE, added on `recall` by the
+ *               sprite-lifecycle work, which imports `name` and
+ *               `actionType` from here rather than restating them.
+ *
+ * ALL SEVEN NOW HAVE VERBS, so the audit's missing set is empty. That
+ * is the finished state, not an absent check -- see the note in
+ * resonance-actions.test.ts about what the tripwire proves once it
+ * empties, because an empty expectation is indistinguishable from one
+ * that never asserted anything.
+ *
+ * `verb` IS THE AUDIT, AND IT IS CHECKED: resonance-actions.test.ts
+ * asserts that every verb named here is really registered in game.ts.
+ * Write a verb that does not exist and the suite fails.
+ *
+ * WHAT IT DOES NOT CATCH, stated plainly because a comment claiming a
+ * guarantee the test does not give is worse than no comment: nothing
+ * detects "somebody implemented Kill Complex Form and forgot to fill in
+ * its verb". No property of a command's NAME proves which canon action
+ * it implements -- an early version of the test tried to guess one from
+ * the other and immediately produced a false positive (`call` is
+ * registered, as the PHONE command, nothing to do with sprites). What
+ * the suite does instead is pin the missing set exactly, so changing it
+ * is a conscious edit rather than a silent drift.
+ *
+ * CITATIONS ARE FIRST-CLASS. Every action type and Test line below was
+ * pinned individually against the rulebooks rather than read off one
+ * contents-page retrieval, because the failure mode this table exists
+ * to prevent is a plausible-sounding invented mechanic. Where canon
+ * could not be confirmed the field is LEFT EMPTY -- see `actionType`.
+ */
+/** Which verb, if any, reaches this action in the game today.
+ *
+ *  `undefined` means NOT IMPLEMENTED, and is asserted as such. When a
+ *  missing action is built, filling this in is the one edit needed --
+ *  and the suite will demand it, because an unimplemented entry whose
+ *  verb suddenly resolves is a table that has gone stale. */
+export type ResonanceVerb = string | undefined;
+export interface IResonanceAction {
+    key: string;
+    /** The book's own name for the action, verbatim from p.250. This is
+     *  the string every surface must render -- imported, never retyped
+     *  (backlog-session-2 imports it for the Call/Dismiss verb). */
+    name: string;
+    /**
+     * SR5e action type, verbatim.
+     *
+     * OPTIONAL ON PURPOSE, and the reason is worth keeping: this field
+     * was very nearly shipped `undefined` for Register Sprite on the
+     * strength of one retrieval that did not happen to include it. A
+     * targeted second query returned "Register Sprite (Complex Action)"
+     * from the section heading itself. All seven are confirmed today --
+     * but the field stays optional so that the NEXT action added here can
+     * be honest about a gap instead of guessing, which is the same rule
+     * the sprite powers follow.
+     */
+    actionType?: 'Simple' | 'Complex';
+    /** The book's Test line, verbatim. `undefined` where the book itself
+     *  gives none -- the two Simple actions genuinely print "Test: n/a",
+     *  which is canon saying "no roll", not canon being unavailable. */
+    test?: string;
+    /** What it does, in one line, for a player reading a list. */
+    effect: string;
+    /** See ResonanceVerb. */
+    verb: ResonanceVerb;
+    /** SR5e core page. */
+    page: string;
+}
+/**
+ * All seven, in the book's own alphabetical order (p.250).
+ *
+ * Kept in canon order rather than "implemented first" order so that
+ * comparing this against the page is a straight read down the column --
+ * which is exactly the check the backlog item asked for, and a check
+ * nobody will run again if it needs re-sorting first.
+ */
+export declare const RESONANCE_ACTIONS: IResonanceAction[];
+/** The book's list, for a caller that wants the canon side alone. */
+export declare const RESONANCE_ACTION_NAMES: string[];
+/** Look one up by key. Used by the surfaces that render a single
+ *  action's name and type rather than the whole table. */
+export declare function resonanceAction(key: string): IResonanceAction | undefined;
+/** The canon actions this game does NOT yet reach with any verb.
+ *
+ *  The backlog item's actual question, answerable in code. */
+export declare function unimplementedResonanceActions(): IResonanceAction[];

package/bundle/typescript/src/commands/game/sideQuest/resonance-actions.js

@@ -0,0 +1,186 @@
+/**
+ * SR5e RESONANCE ACTIONS (core p.250) -- the technomancer's own action
+ * list, and the Resonance-side counterpart to the Matrix actions every
+ * other decker shares.
+ *
+ * WHY THIS IS A TABLE AND NOT SEVEN STRINGS IN SEVEN FILES.
+ *
+ * Backlog item SoopwuTFBwayCGhM9 ("check page 250 for resonance
+ * actions, right now we have several missing") could only be ANSWERED
+ * by laying the book's list beside the game's verbs -- and once that
+ * comparison exists, leaving it in a commit message means the next
+ * person re-derives it. So the comparison lives here, in the `verb`
+ * field, where it is machine-checkable rather than remembered.
+ *
+ * The audit that produced it, in one line each:
+ *   present  -- Compile, Decompile, Register, Thread (already built)
+ *   present  -- COMMAND SPRITE, via the generic `order` verb. This one
+ *               nearly got filed as missing: order.ts picks out of
+ *               `game.companions` with no kind filter, so it has always
+ *               reached sprites. A "missing" feature that already
+ *               exists gets built twice and the second one wins quietly.
+ *   built    -- KILL COMPLEX FORM, added as `unravel` against this
+ *               audit (see unravel.ts).
+ *   built    -- CALL/DISMISS SPRITE, added on `recall` by the
+ *               sprite-lifecycle work, which imports `name` and
+ *               `actionType` from here rather than restating them.
+ *
+ * ALL SEVEN NOW HAVE VERBS, so the audit's missing set is empty. That
+ * is the finished state, not an absent check -- see the note in
+ * resonance-actions.test.ts about what the tripwire proves once it
+ * empties, because an empty expectation is indistinguishable from one
+ * that never asserted anything.
+ *
+ * `verb` IS THE AUDIT, AND IT IS CHECKED: resonance-actions.test.ts
+ * asserts that every verb named here is really registered in game.ts.
+ * Write a verb that does not exist and the suite fails.
+ *
+ * WHAT IT DOES NOT CATCH, stated plainly because a comment claiming a
+ * guarantee the test does not give is worse than no comment: nothing
+ * detects "somebody implemented Kill Complex Form and forgot to fill in
+ * its verb". No property of a command's NAME proves which canon action
+ * it implements -- an early version of the test tried to guess one from
+ * the other and immediately produced a false positive (`call` is
+ * registered, as the PHONE command, nothing to do with sprites). What
+ * the suite does instead is pin the missing set exactly, so changing it
+ * is a conscious edit rather than a silent drift.
+ *
+ * CITATIONS ARE FIRST-CLASS. Every action type and Test line below was
+ * pinned individually against the rulebooks rather than read off one
+ * contents-page retrieval, because the failure mode this table exists
+ * to prevent is a plausible-sounding invented mechanic. Where canon
+ * could not be confirmed the field is LEFT EMPTY -- see `actionType`.
+ */
+/**
+ * All seven, in the book's own alphabetical order (p.250).
+ *
+ * Kept in canon order rather than "implemented first" order so that
+ * comparing this against the page is a straight read down the column --
+ * which is exactly the check the backlog item asked for, and a check
+ * nobody will run again if it needs re-sorting first.
+ */
+export const RESONANCE_ACTIONS = [
+    {
+        key: 'call-dismiss-sprite',
+        name: 'Call/Dismiss Sprite',
+        actionType: 'Simple',
+        // Canon prints "Test: n/a" -- no roll, and no Fading either. That
+        // is what makes it a state transition rather than a gamble, and it
+        // is why the verb belongs with the registered-sprite store.
+        test: undefined,
+        effect: 'Call a registered sprite waiting in the Resonance (it arrives at the start of the next Combat Turn), or send one back -- releasing any tasks it still owes you.',
+        // OWNED BY backlog-session-2 (sprite lifecycle). Coordinator split
+        // this action deliberately: the verb and its state are theirs, the
+        // catalogue entry is this table's. They import `name` and
+        // `actionType` from here rather than writing a second copy that
+        // agrees today and drifts on the first edit.
+        //
+        // IMPLEMENTED on `recall`, not `call`: `call` is CallCommand, the
+        // phone, so claiming it would have cost a technomancer the ability
+        // to ring their fixer. `recall` already meant "bring my thing home
+        // to me" for drones and agents, and it was also LYING to
+        // technomancers -- "Nothing of yours is in the air" with a sprite
+        // standing there -- so one verb fixed the falsehood and the missing
+        // action together. Bare "recall" only CALLS; dismissing has to be
+        // asked for by name, because p.250 releases every task owed.
+        verb: 'recall',
+        page: 'p.250',
+    },
+    {
+        key: 'command-sprite',
+        name: 'Command Sprite',
+        actionType: 'Simple',
+        test: undefined,
+        effect: 'Tell a sprite to do something for you, spending one of its tasks.',
+        // ALREADY IMPLEMENTED, and the reason this table has a `verb`
+        // column at all. `order <sprite> <command>` has always worked:
+        // OrderCommand selects from game.companions with no kind filter,
+        // and a sprite is a companion of kind 'sprite' (game.ts). Verified
+        // by test, not by reading.
+        verb: 'order',
+        page: 'p.250',
+    },
+    {
+        key: 'compile-sprite',
+        name: 'Compile Sprite',
+        actionType: 'Complex',
+        test: 'Compiling + Resonance [Level] v. Sprite Level',
+        effect: 'Thread a sprite out of raw Resonance. Net hits become its tasks; Fading follows.',
+        verb: 'compile',
+        page: 'p.250',
+    },
+    {
+        key: 'decompile-sprite',
+        name: 'Decompile Sprite',
+        actionType: 'Complex',
+        // DECOMPILING, a separate skill from Compiling (p.143). Recorded
+        // verbatim because the distinction is load-bearing and was being
+        // lost: the game rolled `compiling` for decompiling in one place,
+        // which backlog-session-2 is fixing against this citation.
+        test: 'Decompiling + Resonance [Level] v. Sprite Rating (+ compiler\'s Resonance)',
+        effect: 'Unravel a sprite thread by thread -- your own, or a hostile construct on the grid.',
+        verb: 'decompile',
+        page: 'p.250',
+    },
+    {
+        key: 'kill-complex-form',
+        name: 'Kill Complex Form',
+        actionType: 'Complex',
+        test: 'Software + Resonance [Level] v. Complex Form Level + Resonance',
+        effect: 'End a complex form another technomancer is sustaining, without asking. Net hits eat the original threading hits; reach zero and it collapses. You resist Fading as though you had threaded it yourself.',
+        // BUILT (unravel.ts). The game already knew this hole was here:
+        // dispel.ts refuses counterspelling against Resonance with a
+        // deliberate, correct line ("What's woven around X isn't mana --
+        // it's RESONANCE"), naming a gap it had no route to fill. That
+        // refusal now points at a real verb.
+        //
+        // Reaches nothing in a SOLO game today -- not because the route is
+        // closed but because it is GATED. An NPC can reach ThreadCommand
+        // via `order` (NPC.runCommand parses the same registry), and is
+        // refused by its isTechnomancer() check. No NPC is a technomancer
+        // today, so none holds a form and a solo runner meets no weave to
+        // cut. Live on shared runs, and implemented against any form-holder
+        // so it comes alive through the existing path the day one exists.
+        // Recorded here because a verb whose target class is thin should
+        // say so somewhere durable -- and because "impossible" and "gated"
+        // imply very different costs for that feature. See unravel.ts for
+        // the full writer set, and for why a name-grep misses one of them.
+        verb: 'unravel',
+        page: 'p.250',
+    },
+    {
+        key: 'register-sprite',
+        name: 'Register Sprite',
+        actionType: 'Complex',
+        test: 'Registering + Resonance [Level] v. Sprite Level x 2',
+        effect: 'Bind a compiled sprite permanently: it gains tasks, survives travel, and rides your save.',
+        verb: 'register',
+        page: 'p.250',
+    },
+    {
+        key: 'thread-complex-form',
+        name: 'Thread Complex Form',
+        actionType: 'Complex',
+        // "v. special" is the book's own wording -- the opposition depends
+        // on the form being threaded. Left verbatim rather than expanded,
+        // because expanding it here would be inventing a number.
+        test: 'Software + Resonance [Level] v. special',
+        effect: 'Weave a complex form out of the Resonance, instant or sustained.',
+        verb: 'thread',
+        page: 'p.250',
+    },
+];
+/** The book's list, for a caller that wants the canon side alone. */
+export const RESONANCE_ACTION_NAMES = RESONANCE_ACTIONS.map(a => a.name);
+/** Look one up by key. Used by the surfaces that render a single
+ *  action's name and type rather than the whole table. */
+export function resonanceAction(key) {
+    return RESONANCE_ACTIONS.find(a => a.key === key);
+}
+/** The canon actions this game does NOT yet reach with any verb.
+ *
+ *  The backlog item's actual question, answerable in code. */
+export function unimplementedResonanceActions() {
+    return RESONANCE_ACTIONS.filter(a => !a.verb);
+}
+//# sourceMappingURL=resonance-actions.js.map

package/bundle/typescript/src/commands/game/sideQuest/resonance-actions.js.map

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

package/bundle/typescript/src/commands/game/sideQuest/sprite-powers.d.ts

@@ -0,0 +1,88 @@
+/**
+ * SR5e SPRITE POWERS (core p.256-257) and the sprite database's power
+ * assignments (p.259).
+ *
+ * Backlog item Sz7EmXnyRYK4RYqxt, in the reporter's words: "sprite
+ * actions should be listed some how, found on pages 256, 257 and 258,
+ * sprites have abilities unique to them that not even technomancers
+ * have." That last clause is the whole point of the feature -- a
+ * technomancer's own surface (`thread`, complex forms) says nothing
+ * about what the thing standing next to them can do, so the abilities
+ * that make each sprite type worth compiling are invisible at the exact
+ * moment you choose one.
+ *
+ * WHY A SEPARATE MODULE FROM compile.ts's SPRITE_TYPES. The obvious
+ * home is a `powers` field on ISpriteType, and it is the wrong one
+ * right now: compile.ts is the sprite LIFECYCLE surface, owned by
+ * another session mid-repair. Powers are catalogue. Keying this table
+ * by the same five keys costs one join and keeps the two edits from
+ * landing in one file. If the lifecycle work settles and someone wants
+ * them merged later, the join is the seam to delete.
+ *
+ * ALL NINE POWERS ARE CANON-CONFIRMED, each pinned by its own targeted
+ * query rather than read off a contents page -- the standing rule for
+ * this work being that a wrong power on a sprite is worse than a
+ * missing one. Nothing here is inferred, and nothing was left out for
+ * lack of a citation. Every one of the nine is assigned to at least one
+ * sprite type, and the five types' assignments account for all nine
+ * exactly once -- the book's own list closes.
+ *
+ * WHAT THIS IS NOT. These are REFERENCE, not mechanics: no power below
+ * is wired to a die roll in this engine yet, and `sprites.ts` says so
+ * on the panel rather than implying otherwise. Listing an ability the
+ * game cannot actually perform, without saying so, is the same defect
+ * as a refusal naming a route that does not exist -- the game has paid
+ * for that shape more than once. The listing answers "what is this
+ * thing FOR", which is what was asked; it does not promise a verb.
+ */
+export interface ISpritePower {
+    key: string;
+    /** The book's own name. */
+    name: string;
+    /** What it does, close to the book's wording but readable at a
+     *  terminal -- this is a player-facing panel, not a rules quote. */
+    effect: string;
+    /** The book's Test line, where the power has one. `undefined` is
+     *  canon saying "no roll" (Camouflage, Hash, Stability, Watermark are
+     *  states the sprite maintains, not attacks it makes) -- NOT canon
+     *  being unavailable. */
+    test?: string;
+    /** SR5e core page. */
+    page: string;
+}
+/** All nine, alphabetical as the book lists them (p.256). */
+export declare const SPRITE_POWERS: ISpritePower[];
+/**
+ * The sprite database's assignments (p.259), keyed to compile.ts's
+ * SPRITE_TYPES so the two join on the same five keys.
+ *
+ * Skills are the book's, listed because they explain the powers: a
+ * machine sprite has Hardware, which is what Diagnostics and Gremlins
+ * both roll. The pairing is the answer to "why would I compile this
+ * one", which is the question the item is really about.
+ */
+export interface ISpritePowerSet {
+    /** Matches a key in compile.ts's SPRITE_TYPES. */
+    spriteKey: string;
+    /** Keys into SPRITE_POWERS. */
+    powers: string[];
+    /** The book's skill list for the type. */
+    skills: string[];
+    page: string;
+}
+export declare const SPRITE_POWER_SETS: ISpritePowerSet[];
+/** One power by key. */
+export declare function spritePower(key: string): ISpritePower | undefined;
+/** The powers a given sprite type has, resolved. Unknown type -> []. */
+export declare function powersForSprite(spriteKey: string): ISpritePower[];
+/** The skills the book gives a sprite type. Unknown type -> []. */
+export declare function skillsForSprite(spriteKey: string): string[];
+/**
+ * A single use of a sprite power costs one TASK (p.254). Sustaining one
+ * it has already started does not cost more -- unless you change it,
+ * such as switching targets.
+ *
+ * Lives here as the one line every surface that mentions a power needs
+ * beside it, so the cost is not re-stated (and re-worded) per panel.
+ */
+export declare const SPRITE_POWER_TASK_RULE = "Using a power costs one task. Sustaining one already running is free -- until you change it, such as switching targets (p.254).";

package/bundle/typescript/src/commands/game/sideQuest/sprite-powers.js

@@ -0,0 +1,137 @@
+/**
+ * SR5e SPRITE POWERS (core p.256-257) and the sprite database's power
+ * assignments (p.259).
+ *
+ * Backlog item Sz7EmXnyRYK4RYqxt, in the reporter's words: "sprite
+ * actions should be listed some how, found on pages 256, 257 and 258,
+ * sprites have abilities unique to them that not even technomancers
+ * have." That last clause is the whole point of the feature -- a
+ * technomancer's own surface (`thread`, complex forms) says nothing
+ * about what the thing standing next to them can do, so the abilities
+ * that make each sprite type worth compiling are invisible at the exact
+ * moment you choose one.
+ *
+ * WHY A SEPARATE MODULE FROM compile.ts's SPRITE_TYPES. The obvious
+ * home is a `powers` field on ISpriteType, and it is the wrong one
+ * right now: compile.ts is the sprite LIFECYCLE surface, owned by
+ * another session mid-repair. Powers are catalogue. Keying this table
+ * by the same five keys costs one join and keeps the two edits from
+ * landing in one file. If the lifecycle work settles and someone wants
+ * them merged later, the join is the seam to delete.
+ *
+ * ALL NINE POWERS ARE CANON-CONFIRMED, each pinned by its own targeted
+ * query rather than read off a contents page -- the standing rule for
+ * this work being that a wrong power on a sprite is worse than a
+ * missing one. Nothing here is inferred, and nothing was left out for
+ * lack of a citation. Every one of the nine is assigned to at least one
+ * sprite type, and the five types' assignments account for all nine
+ * exactly once -- the book's own list closes.
+ *
+ * WHAT THIS IS NOT. These are REFERENCE, not mechanics: no power below
+ * is wired to a die roll in this engine yet, and `sprites.ts` says so
+ * on the panel rather than implying otherwise. Listing an ability the
+ * game cannot actually perform, without saying so, is the same defect
+ * as a refusal naming a route that does not exist -- the game has paid
+ * for that shape more than once. The listing answers "what is this
+ * thing FOR", which is what was asked; it does not promise a verb.
+ */
+/** All nine, alphabetical as the book lists them (p.256). */
+export const SPRITE_POWERS = [
+    {
+        key: 'camouflage',
+        name: 'Camouflage',
+        effect: 'Hides a file inside another file, invisible to Matrix searches. Only a Matrix Perception Test specifically hunting the hidden file will turn it up -- and the sprite has to make that test too, to get its own file back out.',
+        test: undefined,
+        page: 'p.256',
+    },
+    {
+        key: 'cookie',
+        name: 'Cookie',
+        effect: 'Tags a persona with a silent tracking file rated at the sprite\'s Level. It logs every host entered, every program used, and who was talked to and when (not what was said). Net hits set the depth: one hit is a bare outline, four or more a detailed report. At a time set when it was placed the file ships itself back to the sprite -- and deletes itself instead if the sprite has left the Matrix. A Matrix Perception Test on the carrier finds it; unprotecting it and deleting it removes it.',
+        test: 'Hacking + Resonance [Sleaze] v. Intuition + Firewall',
+        page: 'p.256-257',
+    },
+    {
+        key: 'diagnostics',
+        name: 'Diagnostics',
+        effect: 'Reads a device down to its seams and helps somebody use or repair it, as a Teamwork Test. Any hits give +1 limit, and each hit adds a die to their pool. It takes the sprite\'s whole attention -- the bonus lasts until it drops the power or does anything else.',
+        test: 'Simple Hardware + Level [Data Processing]',
+        page: 'p.257',
+    },
+    {
+        key: 'electron-storm',
+        name: 'Electron Storm',
+        effect: 'Engulfs a persona in a sustained barrage of corrupting datastreams. On the first hit and on every action the sprite spends sustaining it, the target takes (Resonance) DV Matrix damage, resisted as normal, plus 2 points of noise. If the sprite takes any Matrix damage of its own, every storm it is sustaining ends at once.',
+        test: 'Cybercombat + Resonance [Attack] v. Intuition + Firewall',
+        page: 'p.257',
+    },
+    {
+        key: 'gremlins',
+        name: 'Gremlins',
+        effect: 'Makes a device misbehave -- a jammed control, a looped signal, a faulty reading. Success is a glitch; four or more net hits is a critical one, and the device crashes, burns out, or bites its user.',
+        test: 'Hardware + Level [Attack] v. Device Rating + Firewall',
+        page: 'p.257',
+    },
+    {
+        key: 'hash',
+        name: 'Hash',
+        effect: 'Seals a file with a Resonance algorithm only that sprite can undo, for up to (Level x 10) Combat Turns. Put the file down and it reverts to normal. Destroy the sprite while it still carries the file and the file is corrupted for good.',
+        test: undefined,
+        page: 'p.257',
+    },
+    {
+        key: 'stability',
+        name: 'Stability',
+        effect: 'Steadies any persona or device the sprite holds a mark on: standard glitches are ignored outright and critical glitches drop to standard. It stops induced accidents too, Gremlins included -- which is why a machine sprite can both cause and prevent them.',
+        test: undefined,
+        page: 'p.257',
+    },
+    {
+        key: 'suppression',
+        name: 'Suppression',
+        effect: 'Baffles a host into hesitating. A sprite using this inside a host delays any IC it launches by (Level / 2) Combat Turns, and delayed IC can neither act nor be targeted.',
+        test: undefined,
+        page: 'p.257',
+    },
+    {
+        key: 'watermark',
+        name: 'Watermark',
+        effect: 'Marks an icon invisibly, readable only by Resonance-driven things -- a way to leave messages on Matrix objects that nobody else can see. A new watermark overwrites an old one, and it lasts as long as the icon does unless somebody erases the Matrix signature.',
+        test: undefined,
+        page: 'p.257',
+    },
+];
+export const SPRITE_POWER_SETS = [
+    { spriteKey: 'courier', powers: ['cookie', 'hash'], skills: ['Computer', 'Hacking'], page: 'p.259' },
+    { spriteKey: 'crack', powers: ['suppression'], skills: ['Computer', 'Electronic Warfare', 'Hacking'], page: 'p.259' },
+    { spriteKey: 'data', powers: ['camouflage', 'watermark'], skills: ['Computer', 'Electronic Warfare'], page: 'p.259' },
+    { spriteKey: 'fault', powers: ['electron-storm'], skills: ['Computer', 'Cybercombat', 'Hacking'], page: 'p.259' },
+    { spriteKey: 'machine', powers: ['diagnostics', 'gremlins', 'stability'], skills: ['Computer', 'Electronic Warfare', 'Hardware'], page: 'p.259' },
+];
+/** One power by key. */
+export function spritePower(key) {
+    return SPRITE_POWERS.find(p => p.key === key);
+}
+/** The powers a given sprite type has, resolved. Unknown type -> []. */
+export function powersForSprite(spriteKey) {
+    const set = SPRITE_POWER_SETS.find(s => s.spriteKey === spriteKey);
+    if (!set)
+        return [];
+    // Resolved through spritePower() rather than trusted: a key naming no
+    // power would otherwise render as a silent gap in the panel.
+    return set.powers.map(k => spritePower(k)).filter((p) => !!p);
+}
+/** The skills the book gives a sprite type. Unknown type -> []. */
+export function skillsForSprite(spriteKey) {
+    return SPRITE_POWER_SETS.find(s => s.spriteKey === spriteKey)?.skills ?? [];
+}
+/**
+ * A single use of a sprite power costs one TASK (p.254). Sustaining one
+ * it has already started does not cost more -- unless you change it,
+ * such as switching targets.
+ *
+ * Lives here as the one line every surface that mentions a power needs
+ * beside it, so the cost is not re-stated (and re-worded) per panel.
+ */
+export const SPRITE_POWER_TASK_RULE = 'Using a power costs one task. Sustaining one already running is free -- until you change it, such as switching targets (p.254).';
+//# sourceMappingURL=sprite-powers.js.map

package/bundle/typescript/src/commands/game/sideQuest/sprite-powers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sprite-powers.js","sourceRoot":"","sources":["../../../../../../src/commands/game/sideQuest/sprite-powers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAkBH,6DAA6D;AAC7D,MAAM,CAAC,MAAM,aAAa,GAAmB;IAC3C;QACE,GAAG,EAAE,YAAY;QACjB,IAAI,EAAE,YAAY;QAClB,MAAM,EAAE,+NAA+N;QACvO,IAAI,EAAE,SAAS;QACf,IAAI,EAAE,OAAO;KACd;IACD;QACE,GAAG,EAAE,QAAQ;QACb,IAAI,EAAE,QAAQ;QACd,MAAM,EAAE,0eAA0e;QAClf,IAAI,EAAE,sDAAsD;QAC5D,IAAI,EAAE,WAAW;KAClB;IACD;QACE,GAAG,EAAE,aAAa;QAClB,IAAI,EAAE,aAAa;QACnB,MAAM,EAAE,oQAAoQ;QAC5Q,IAAI,EAAE,2CAA2C;QACjD,IAAI,EAAE,OAAO;KACd;IACD;QACE,GAAG,EAAE,gBAAgB;QACrB,IAAI,EAAE,gBAAgB;QACtB,MAAM,EAAE,mUAAmU;QAC3U,IAAI,EAAE,0DAA0D;QAChE,IAAI,EAAE,OAAO;KACd;IACD;QACE,GAAG,EAAE,UAAU;QACf,IAAI,EAAE,UAAU;QAChB,MAAM,EAAE,sMAAsM;QAC9M,IAAI,EAAE,uDAAuD;QAC7D,IAAI,EAAE,OAAO;KACd;IACD;QACE,GAAG,EAAE,MAAM;QACX,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,4OAA4O;QACpP,IAAI,EAAE,SAAS;QACf,IAAI,EAAE,OAAO;KACd;IACD;QACE,GAAG,EAAE,WAAW;QAChB,IAAI,EAAE,WAAW;QACjB,MAAM,EAAE,+PAA+P;QACvQ,IAAI,EAAE,SAAS;QACf,IAAI,EAAE,OAAO;KACd;IACD;QACE,GAAG,EAAE,aAAa;QAClB,IAAI,EAAE,aAAa;QACnB,MAAM,EAAE,0KAA0K;QAClL,IAAI,EAAE,SAAS;QACf,IAAI,EAAE,OAAO;KACd;IACD;QACE,GAAG,EAAE,WAAW;QAChB,IAAI,EAAE,WAAW;QACjB,MAAM,EAAE,oQAAoQ;QAC5Q,IAAI,EAAE,SAAS;QACf,IAAI,EAAE,OAAO;KACd;CACF,CAAC;AAqBF,MAAM,CAAC,MAAM,iBAAiB,GAAsB;IAClD,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,UAAU,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;IACpG,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC,UAAU,EAAE,oBAAoB,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;IACrH,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,YAAY,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC,UAAU,EAAE,oBAAoB,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;IACrH,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC,UAAU,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;IACjH,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,aAAa,EAAE,UAAU,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC,UAAU,EAAE,oBAAoB,EAAE,UAAU,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;CAClJ,CAAC;AAEF,wBAAwB;AACxB,MAAM,UAAU,WAAW,CAAC,GAAW;IACrC,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;AAChD,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,eAAe,CAAC,SAAiB;IAC/C,MAAM,GAAG,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC;IACnE,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,CAAC;IACpB,sEAAsE;IACtE,6DAA6D;IAC7D,OAAO,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAqB,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACnF,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,eAAe,CAAC,SAAiB;IAC/C,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,SAAS,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC;AAC9E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,sBAAsB,GACjC,iIAAiI,CAAC"}

package/bundle/typescript/src/commands/game/sideQuest/types/repro.d.ts

@@ -0,0 +1,106 @@
+import { Direction } from './shared/direction-enum.js';
+import { DeviceSeedKind } from './seed/device-seed.js';
+/**
+ * A REPRO FIXTURE -- the bench a review item ships with itself.
+ *
+ * The problem this exists for, in the reporter's words: "Many backlog
+ * items are found during a run, so reproducing them for testing is
+ * difficult... I'm trying to review the item fixed by commit 359ad1fe.
+ * But I can't get to a barrier like a lock or ward."
+ *
+ * That is exactly true, and not a discoverability problem -- the static
+ * scenes carry no devices at all, so there is nowhere in the shipped
+ * game to go and stand in front of a maglock. Every fix that touches a
+ * barrier has been unconfirmable for the same reason.
+ *
+ * WHY A SPEC AND NOT A SCENE. The obvious answer is to grow one scene a
+ * fixture per item, and the reporter rejected it: the fixtures pile up
+ * forever, in a scene that doubles as the generation-failure fallback
+ * for ordinary players, inside the shipped binary and in git for good.
+ * So each item carries a ~20-line spec instead, and the client builds a
+ * two-room bench from it on demand. Nothing accumulates anywhere.
+ *
+ * WHY INTENT AND NOT STRUCTURE. Everything here says what the bench is
+ * FOR, never how to wire it. `atDoorway: true` is a statement about the
+ * fiction; deriving the spot name it implies is the builder's job, and
+ * that division is the whole design (see factories/repro-scene.ts).
+ * Hand-authored seed JSON can be subtly wrong in the way this codebase
+ * keeps shipping -- a check whose two sides fail together cannot see
+ * the failure -- and a repro that quietly proves the opposite of what
+ * it claims is worse than no repro at all.
+ */
+/** Which side of the sealed door something stands on. The BARRIER side
+ *  is the room the device is in and the room that declares the exit it
+ *  seals; the FAR side is through the door. */
+export type ReproSide = 'barrier' | 'far';
+export interface IReproBarrier {
+    kind: DeviceSeedKind;
+    /** Defaults per kind -- Maglock, Keypad, Chalk Ward. */
+    name?: string;
+    /** The credential it answers to. PANEL ONLY, and the builder refuses
+     *  it elsewhere rather than dropping it: "if it's a _mechanical_ lock,
+     *  it has a key or can be picked. You can't talk at a _mechanical_
+     *  lock." A code that silently does nothing is a repro that proves
+     *  nothing. */
+    code?: string;
+    /** An item that opens it outright. Placed on the runner's own side. */
+    keyItem?: string;
+    /** Start it ALREADY OPEN. Not a curiosity -- an NPC's brief has to be
+     *  right about an opened barrier too, and getting that wrong is a
+     *  live item on the board. */
+    open?: boolean;
+    /** The exit it seals. Defaults to north. */
+    sealsExit?: Direction;
+}
+export interface IReproNpc {
+    name: string;
+    /** What they are, in a sentence. Becomes the description AND the AI
+     *  brief, so an NPC in a repro is briefed the way a real one is --
+     *  which matters, because half these items are about what an NPC
+     *  believes about a door. */
+    concept: string;
+    side?: ReproSide;
+    /** Standing IN the sealed doorway. */
+    atDoorway?: boolean;
+    /** Holding it shut: a doorman, a picket. Implies atDoorway, because a
+     *  guard who is not in the doorway guards nothing. */
+    guarding?: boolean;
+}
+export interface IReproItem {
+    name: string;
+    description: string;
+    /** The long read, for a clue that carries a code. */
+    details?: string;
+    side?: ReproSide;
+}
+export interface IReproFixture {
+    /** Plain-English framing, printed above the steps. */
+    premise?: string;
+    /** Names an ARCHETYPES entry and decides the pregen. Defaults to
+     *  Covert Ops, which carries the Lockpick Set and locksmith 5 -- so a
+     *  lock repro works without anyone having to think about it. */
+    archetype?: string;
+    /** Omitted for a repro that needs a scene and no obstacle. */
+    barrier?: IReproBarrier;
+    npcs?: IReproNpc[];
+    items?: IReproItem[];
+    /** Which side the runner starts on. Defaults to the barrier side. */
+    start?: ReproSide;
+}
+export interface IRepro {
+    fixture?: IReproFixture;
+    /** Framing for the READER, printed above the steps.
+     *
+     *  Lives here and not only on the fixture because a repro can have no
+     *  fixture at all -- some items are about a verb or a menu -- and the
+     *  one line explaining what you are looking at should not depend on
+     *  there being a scene. When a fixture has none of its own, this
+     *  becomes the bench's story too. */
+    premise?: string;
+    /** The literal commands to type, in order -- and the same strings the
+     *  walkthrough test replays. Steps that only a human can read are
+     *  steps that rot. */
+    steps: string[];
+    /** What passing looks like. */
+    expect?: string;
+}

package/bundle/typescript/src/commands/game/sideQuest/types/repro.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=repro.js.map

package/bundle/typescript/src/commands/game/sideQuest/types/repro.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repro.js","sourceRoot":"","sources":["../../../../../../../src/commands/game/sideQuest/types/repro.ts"],"names":[],"mappings":""}