@maka/maka-cli 5.226.0 → 5.228.0

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.226.0",
+  "version": "5.228.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",

package/bundle/typescript/src/commands/game/sideQuest/commands/disable.js

@@ -134,7 +134,20 @@ export class DisableCommand extends Command {
             return t.viaWan && t.host?.host ? wanDefensePool(t.device, t.host.host) : deviceDefensePool(t.device);
         }
         if (t.kind === 'camera') {
-            return t.master?.host ? hostDefensePool(t.master.host) : { label: 'Device Rating + Firewall', pool: 4 };
+            // THE LENSES RATE WHAT THE SITE SAYS THEY RATE (Room.cameraRating,
+            // eJANPpm7qCaCAJBJw). This used to borrow the host's whole pool
+            // while silent-icons.ts hid the same cluster behind a hard-coded 4
+            // and the icon line printed no rating at all -- three answers to
+            // one question, two of them invisible. A slaved camera still
+            // borrows its master where the master is HIGHER (p.233, the same
+            // rule wanDefensePool applies to a slaved device), so a corp host
+            // still hardens its own cameras; what changed is that the floor is
+            // the seeded rating rather than a constant nobody could read.
+            const own = { label: 'Device Rating + Firewall', pool: Math.max(0, t.room.cameraRating * 2) };
+            if (!t.master?.host)
+                return own;
+            const viaHost = hostDefensePool(t.master.host);
+            return viaHost.pool >= own.pool ? viaHost : own;
         }
         return { label: 'Intuition + Firewall', pool: t.owner.getPanDefensePool('sleaze') };
     }

package/bundle/typescript/src/commands/game/sideQuest/commands/look.js

@@ -333,7 +333,17 @@ export class LookCommand extends Command {
         // in the icon block below rather than one look later.
         const swept = spotHiddenIcons(this.scene, this.actor, this.actor.insideHost === room ? room : gridVicinity(this.actor));
         const lines = [gridSculpt(this.actor, room)];
-        lines.push(gridIconBlock(this.scene, this.actor, room, this.rooms));
+        // THE SWEEP IS REPORTED BEFORE THE LIST IT CHANGED
+        // (eJANPpm7qCaCAJBJw, third rejection: "I still see the Service
+        // Keypad and Camera cluster").
+        //
+        // The sweep runs first so anything it wins appears in this look
+        // rather than one look later -- that part was right. But its
+        // SENTENCE was pushed after the icon block, so the player read a
+        // newly-revealed keypad with nothing above it saying why, and the
+        // "you pick an icon out of the noise" line arrived two blocks down.
+        // Revealing something and explaining it in that order reads exactly
+        // like never having hidden it, which is what was reported.
         if (swept) {
             lines.push(spotLine(swept));
             if (showsMechanics(this.scene, this.actor)) {
@@ -342,6 +352,7 @@ export class LookCommand extends Command {
                 }
             }
         }
+        lines.push(gridIconBlock(this.scene, this.actor, room, this.rooms, swept?.found));
         // THE COACHING HAS TO MATCH THE ROOM YOU ARE IN. Inside a host,
         // `go` is refused (go.ts checkHostBoundary) and `map` draws the
         // outside grid you cannot reach -- so offering both is the same

package/bundle/typescript/src/commands/game/sideQuest/engine-version.js

@@ -1251,9 +1251,13 @@
 //     'panel' -- the maglock, the keypad, the safe). A ward is the Art
 //     and has no wireless mode to hide in.
 //   - CAMERAS TOO, which p.217 names FIRST. The cluster is not a Device
-//     (it is derived from the room), so it hides on Room.camerasSpottedBy
-//     and resists with its master host's rating -- a site's lenses are as
-//     quiet as the security that runs them.
+//     (it is derived from the room), so it hides on Room.camerasSpottedBy.
+//     (This entry ORIGINALLY said it resisted with its MASTER HOST'S
+//     rating. That was wrong and 1.80.1 removed it the same day -- a
+//     lens behind a rating-8 host was a 16-die hide against a sweep
+//     capped near 5, and it measured ZERO finds in twelve looks. It
+//     resists with its own rating; see 1.82.0 for where that number
+//     now lives.)
 //   - AND PEOPLE. Going dark used to make an icon simply unfindable:
 //     isLinked answers false and nothing anywhere rolled to beat it, so
 //     the book's own example of a hidden icon was the one case with no
@@ -1325,5 +1329,47 @@
 //   hole had been open: they leaned on the old "no gear, stay quiet"
 //   branch and have been rolling unlimited all along. They carry decks
 //   now. The VR gate (a direct neural interface, p.222-223) is untouched.
-export const ENGINE_VERSION = '1.81.0';
+// 1.82.0 (2026-09-16): WHAT MATRIX PERCEPTION BUYS MUST BE EARNED
+//   (eJANPpm7qCaCAJBJw, third rejection). 1.80.0 hid the ICON and stopped
+//   there. The reporter read the transcript and found the rest:
+//     "I shouldn't even see 'Service Keypad hides' at all if I don't
+//      clear the firewall."
+//   They were right, and the leak was in the DICE, not the prose. The
+//   narrative line was correctly vague -- "something here is running
+//   silent and you cannot pin it" -- and then the mechanics pane named
+//   the thing on the very next line, win or lose:
+//     Service Keypad hides (Device Rating (no Logic to hide behind)): 6d6 -> 2 hits
+//   A FAILED SWEEP TAUGHT YOU MORE THAN A SUCCESSFUL ONE WOULD HAVE.
+//   - A LOST SWEEP NAMES NOTHING. ISpotOutcome.missed is now a COUNT,
+//     not a list of names, and the losing branch of the loop never puts
+//     a name in the outcome at all. This is the shape of the fix that
+//     matters: the old type carried the names and merely trusted every
+//     caller to remember not to print them. A name that was never earned
+//     cannot now be printed by accident, because it is not there. The
+//     dice still show: "something holds its cover: 6d6 -> 2 hits".
+//   - RATINGS ARE PROTECTED TOO, which is the reporter's other question
+//     answered. p.235 sells "the target's device rating" for a hit, and
+//     the engine printed [DR n] on every icon for free. It is now
+//     [DR ?] until the icon is yours: ratingKnownBy = not silent, or
+//     spotted by you. NOTE THE SMALLER CLAIM -- a never-silent device
+//     shows its rating for nothing. p.235 charges a hit for it even
+//     then; this engine does not, because a loud icon has nothing to
+//     roll against and inventing a resistance for it would be inventing
+//     a rule. Said plainly rather than papered over.
+//   - THE CAMERA CLUSTER HAS A RATING AT LAST, which was the third
+//     complaint. Room.cameraRating, ONE number, feeding all three places
+//     that disagreed: what it hides behind (Device Rating + Firewall),
+//     what it defends Control Device / Data Spike with, and what the
+//     grid prints. It is 1 (p.356 lists Camera at 1; the same list gives
+//     the door lock the 2 the engine already uses). It is a FIELD, so a
+//     corp floor that wants p.421's mil-spec band is a one-line change
+//     in the seed layer, not a rewrite.
+//   - AND THE SWEEP READS AS A SWEEP: the narration moved ABOVE the icon
+//     block (you were reading revealed icons before the sentence that
+//     explained them), and an icon found this look is tagged "<- just
+//     spotted, was running silent". Without the tag, every later look
+//     shows it with no explanation at all -- indistinguishable from an
+//     icon that was never hidden, which is most of why 1.80.0 read to
+//     the reporter as nothing having happened.
+export const ENGINE_VERSION = '1.82.0';
 //# sourceMappingURL=engine-version.js.map

package/bundle/typescript/src/commands/game/sideQuest/models/room.js

@@ -12,6 +12,13 @@ import { AbstractRoom } from '../types/shared/abstracts.js';
 import { spotsActive, actorDistanceMeters, voiceBandFor, voiceTag, doorwayKindOf, exitDoorwayKind } from '../utilities/spots.js';
 import { canHearSpeech, canHearShout } from '../utilities/earshot.js';
 import { synthesizeGrid, attachExitCell, detachExitCell, } from '../utilities/room-grid.js';
+/**
+ * A CAMERA'S DEVICE RATING when the scene does not say (p.356, which
+ * lists "Camera" at 1 -- the same table that gives the door lock the 2
+ * DEFAULT_DEVICE_RATING already uses). A seed raises it: p.421 bands
+ * ordinary security devices at 2 and mil-spec at 4.
+ */
+export const DEFAULT_CAMERA_RATING = 1;
 export class Room extends AbstractRoom {
     logger = Logger.getInstance();
     actors = new Set();
@@ -74,6 +81,29 @@ export class Room extends AbstractRoom {
      * of the grid.
      */
     camerasSpottedBy = new Set();
+    /**
+     * WHAT THE LENSES RATE (eJANPpm7qCaCAJBJw, third rejection: "the
+     * camera cluster doesn't have a DR"), and the reporter's ruling that
+     * it should be per-site rather than one global number.
+     *
+     * The cluster is not a Device -- it is derived from the room itself
+     * (utilities/surveillance.ts isWatched) -- so it had no rating to
+     * carry, and the codebase had quietly grown THREE answers that
+     * disagreed: it hid behind a hard-coded 4, it defended a Data Spike
+     * with the HOST's pool (commands/disable.ts), and it displayed no
+     * rating at all. One number now feeds all three, so what a player
+     * reads is what it rolls.
+     *
+     * ONE FOR NOW (user ruling 2026-09-16), which is what p.356 lists a
+     * Camera at -- the same table the engine already takes its door-lock 2
+     * from. Per-site seeding was scoped out deliberately: the defect here
+     * was three numbers disagreeing, and one field fixes that without a
+     * seed knob the generator could get wrong. It is a FIELD rather than a
+     * constant so that making it per-site later is a one-line change at
+     * the seed layer and nothing else moves. p.421 bands ordinary security
+     * devices at 2 and mil-spec at 4 when that day comes.
+     */
+    cameraRating = DEFAULT_CAMERA_RATING;
     /**
      * THE FALLEN (player ruling 2026-08-25). A killed actor leaves a BODY
      * where they dropped, holding everything they carried, instead of

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

@@ -1,3 +1,39 @@
+/**
+ * THE BENCH'S ACTOR. One name, used for the seat, for the transcript's
+ * visibility filter, and for the post-boot fixture state below.
+ *
+ * IT LIVES HERE, in the types module, on purpose. utilities/repro-launch
+ * declared it, and the launcher's whole design is that the game graph
+ * (repro-scene, the harness, blessed, 150 files) stays behind a dynamic
+ * import so `maka --help` does not pay for it. Once the site needed the
+ * same constant, anything that re-exported it from a module importing
+ * the builder would have dragged that graph back across the lazy
+ * boundary. This file imports nothing, so both sides can share the name
+ * for free.
+ */
+export const REPRO_ACTOR = 'Tester';
+/**
+ * THE FIXTURE A BENCH ACTUALLY BUILDS FROM.
+ *
+ * One rule, and it is not a convenience: a bench written with
+ * `repro.premise` and no `fixture.premise` is the common shape, so the
+ * reader's framing doubles as the scene's story when the fixture has
+ * none of its own. Three callers build a bench -- the headless dry run,
+ * the CLI's live launcher, and maka-cli.com's web bench -- and each had
+ * to know this. Two of them spelling it the same way and a third
+ * forgetting is how a bench acquires a different opening line depending
+ * on where it was run from.
+ *
+ * Here rather than beside the builder because this file imports nothing,
+ * so the launcher can apply the rule without reaching across its lazy
+ * boundary into the game graph.
+ */
+export function reproFixtureOf(repro) {
+    const fixture = { ...(repro.fixture ?? {}) };
+    if (!fixture.premise && repro.premise)
+        fixture.premise = repro.premise;
+    return fixture;
+}
 /**
  * THE FIXTURE SCHEMA'S VERSION, and the engine side is the source of
  * truth for it. Anything that GENERATES repro drafts -- the

package/bundle/typescript/src/commands/game/sideQuest/utilities/ar.js

@@ -2,6 +2,7 @@ import { isLinked, CALL_COLOR } from './comm-style.js';
 import { isWatched, camerasLive, canSnoopFeeds } from './surveillance.js';
 import { Category } from '../types/shared/item-enum.js';
 import { hint } from './hints.js';
+import { cameraDrTag, drTagFor } from './grid-view.js';
 /**
  * AROs -- AUGMENTED REALITY OBJECTS (player request 2026-08-26: "we
  * need AROs on anything online"). The 2075 street is not bare: anything
@@ -147,9 +148,10 @@ export function aroTags(scene, actor, room) {
         // The verb rides the tag: standing in the room IS the requirement
         // for a direct connection (commands/tap.ts), so this is the one
         // place the player is always in a position to use it.
+        const camDr = cameraDrTag(room, actor.name);
         tags.push(canSnoopFeeds(rooms, room, actor) && !camerasLive(rooms, room)
-            ? `◎ Camera cluster -- wireless, and looping empty hallways for the house.`
-            : `◎ Camera cluster -- wireless, and watching.${hint(` ("tap" cables into it -- a slaved lens can't hide behind its host)`)}`);
+            ? `◎ Camera cluster ${camDr}-- wireless, and looping empty hallways for the house.`
+            : `◎ Camera cluster ${camDr}-- wireless, and watching.${hint(` ("tap" cables into it -- a slaved lens can't hide behind its host)`)}`);
     }
     // THE FIXED DEVICES -- the keypad on the wall, the maglock on the
     // grate (YjBA9xhY2NDmCFw5d, Deditri: "The keypad should be
@@ -174,7 +176,7 @@ export function aroTags(scene, actor, room) {
         // still picked, breached, shot and keyed exactly as before.
         if (!device.hasIconFor(actor.name))
             continue;
-        tags.push(`▤ ${device.name} -- wireless, {bold}[DR ${device.rating}]{/bold}${device.isOpen() ? ', standing open' : `.${hint(` ("${device.verbs()[0]} ${device.name}")`)}`}`);
+        tags.push(`▤ ${device.name} -- wireless, ${drTagFor(device, actor.name)}${device.isOpen() ? ', standing open' : `.${hint(` ("${device.verbs()[0]} ${device.name}")`)}`}`);
     }
     // LOOSE DEVICES lying in plain sight. A wireless deck on a table
     // announces itself; one in a drawer you never opened does not.

package/bundle/typescript/src/commands/game/sideQuest/utilities/grid-view.js

@@ -23,6 +23,65 @@ const NEAR_DIVIDER = '-- and NEAR it, out on the open grid (not inside the host)
 export function isNearDivider(line) {
     return line === NEAR_DIVIDER;
 }
+/**
+ * A DEVICE RATING IS SOMETHING YOU BUY WITH A HIT, not something the
+ * screen gives away (eJANPpm7qCaCAJBJw -- "are device ratings
+ * themselves, protected information?"; p.235).
+ *
+ * p.235 lists what one hit on a Matrix Perception test buys, and "the
+ * target's device rating" is an entry on it, beside "the type of icon"
+ * and "the rating of one of the target's Matrix attributes". The engine
+ * printed [DR n] on every icon for nothing, which is the same defect the
+ * silent-icon work fixed one field over: the rating was free.
+ *
+ * WHAT COUNTS AS HAVING READ IT is the sweep that found the icon
+ * (utilities/silent-icons.ts). Winning it buys the icon AND its rating
+ * together -- one hit, one look, one fact.
+ *
+ * AND A LOUD ICON PUBLISHES ITS RATING, which is where this stops short
+ * of p.235 on purpose. Strictly the book charges a hit for the rating of
+ * ANY icon, loud or not; modelling that needs a per-fact ledger of what
+ * each viewer has bought about each icon, which nothing else in this
+ * engine keeps and which would put a roll between a player and a number
+ * they can already see on the shop window. The first cut gated every
+ * rating on `spottedBy` and the consequence was immediate: a device that
+ * was never silent is never spotted, so its rating read [DR ?] forever
+ * with no way to earn it. So the line is drawn at HIDING -- a rating you
+ * were never meant to see is protected, a rating the thing broadcasts is
+ * not -- and that is a smaller claim than p.235's, stated here rather
+ * than dressed up as the whole rule.
+ */
+export function ratingKnownBy(device, viewerName) {
+    return !device.silent || device.spottedBy.has(viewerName);
+}
+/**
+ * The bracketed rating, or `[DR ?]` when it has not been read.
+ *
+ * A QUESTION MARK RATHER THAN NOTHING, on purpose: the icon's SHAPE is
+ * free (p.219 -- it looks like the thing it is), so a player should see
+ * that this object HAS a rating and that they have not bought it yet.
+ * Printing nothing would read as "this one has no rating", which is a
+ * different and wrong fact, and is exactly the ambiguity that made the
+ * camera cluster's missing DR look like an oversight.
+ */
+export function drTag(known, rating) {
+    return known ? `{bold}[DR ${rating}]{/bold}` : `{bold}[DR ?]{/bold}`;
+}
+/** One rule for both surfaces: the grid and the AR overlay ask this, so
+ *  a rating the street can read and a persona cannot is impossible. */
+export function drTagFor(device, viewerName) {
+    return drTag(ratingKnownBy(device, viewerName), device.rating);
+}
+/** The camera cluster's rating tag. Cameras are always security kit and
+ *  therefore always silent, so unlike a device there is no loud case:
+ *  reading the lenses is the only way to their number. */
+export function cameraDrTag(room, viewerName) {
+    return drTag(room.camerasSpottedBy.has(viewerName), room.cameraRating);
+}
+/** Trailing space for the icon lines that interpolate it mid-sentence. */
+function cameraDr(room, viewerName) {
+    return `${cameraDrTag(room, viewerName)} `;
+}
 /**
  * A DEVICE ICON, AND WHAT WORKS IT (commands/disable.ts, 2026-09-13).
  * Control Device (p.238) needs 2 marks on the device -- "disable" -- and
@@ -30,7 +89,7 @@ export function isNearDivider(line) {
  * locked (p.228), so its line says so rather than offering a way in.
  */
 export function deviceIconLine(device, actor) {
-    const dr = `{bold}[DR ${device.rating}]{/bold}`;
+    const dr = drTag(ratingKnownBy(device, actor.name), device.rating);
     if (device.isOpen())
         return `▤ ${device.name} ${dr} -- its icon standing open, nothing left to hold.`;
     if (device.isBricked) {
@@ -275,10 +334,10 @@ export function gridIcons(scene, actor, room) {
     if (isWatched(room) && room.camerasSpottedBy.has(actor.name)) {
         const rooms = scene.getRooms();
         if (!camerasLive(rooms, room)) {
-            icons.push(`◎ Camera cluster -- looped on empty hallways. Security sees NOTHING here.${canSnoopFeeds(rooms, room, actor) ? ` ("snoop" rides the feeds you own)` : ''}`);
+            icons.push(`◎ Camera cluster ${cameraDr(room, actor.name)}-- looped on empty hallways. Security sees NOTHING here.${canSnoopFeeds(rooms, room, actor) ? ` ("snoop" rides the feeds you own)` : ''}`);
         }
         else if (canSnoopFeeds(rooms, room, actor)) {
-            icons.push(`◎ Camera cluster -- live, and answering to YOU as much as the house. ("snoop <room>" watches remotely)`);
+            icons.push(`◎ Camera cluster ${cameraDr(room, actor.name)}-- live, and answering to YOU as much as the house. ("snoop <room>" watches remotely)`);
         }
         else {
             // Seen from the grid, the cluster is worth naming as a WAY IN,
@@ -296,7 +355,7 @@ export function gridIcons(scene, actor, room) {
             // exactly one, so the reader was left to guess at a fact the
             // engine had already handed them.
             const owner = cameraMasterHost(scene.getRooms(), room);
-            icons.push(`◎ Camera cluster -- live, feeding ${owner ? hostLabel(owner) : `the site's host`}. Loud acts here travel. (own the host to loop them -- or walk in and "tap" a lens in the flesh: slaved to the host means a key to the host)`);
+            icons.push(`◎ Camera cluster ${cameraDr(room, actor.name)}-- live, feeding ${owner ? hostLabel(owner) : `the site's host`}. Loud acts here travel. (own the host to loop them -- or walk in and "tap" a lens in the flesh: slaved to the host means a key to the host)`);
         }
     }
     // THE DIVIDER (eJANPpm7qCaCAJBJw). Only when there is a host to be
@@ -570,14 +629,28 @@ export function gridSculpt(actor, room) {
  * the dimmer their icons"). `rooms` absent means the caller has only
  * the one room, and the block reads as it always did.
  */
-export function gridIconBlock(scene, actor, room, rooms) {
+export function gridIconBlock(scene, actor, room, rooms, justFound) {
     const isHostLine = (i) => i.startsWith('●') || i.startsWith('■');
+    // WHAT THIS LOOK JUST TURNED UP, tagged where it is listed
+    // (eJANPpm7qCaCAJBJw: "I still see the Service Keypad and Camera
+    // cluster"). An icon a sweep has just won is otherwise identical on
+    // the page to one that was never hidden -- and on every LATER look
+    // there is no sweep line at all, because there is nothing left to
+    // roll against, so without this the moment of finding something is
+    // invisible and the whole mechanic reads as not having run.
+    const mark = (icon) => {
+        if (!justFound?.length)
+            return icon;
+        return justFound.some(n => icon.includes(n))
+            ? `${icon} {bold}<- just spotted, was running silent{/bold}`
+            : icon;
+    };
     if (actor.insideHost || !rooms) {
         const icons = gridIcons(scene, actor, room);
         if (icons.length === 0) {
             return `{light-blue-fg}Thin grid out here -- background noise, nothing worth cracking.{/light-blue-fg}`;
         }
-        return `{light-blue-fg}ICONS IN REACH:{/light-blue-fg}\n${icons.map(i => `  {light-blue-fg}${i}{/light-blue-fg}`).join('\n')}`;
+        return `{light-blue-fg}ICONS IN REACH:{/light-blue-fg}\n${icons.map(i => `  {light-blue-fg}${mark(i)}{/light-blue-fg}`).join('\n')}`;
     }
     const out = [];
     const hosts = hostsInReach(rooms, actor);
@@ -629,12 +702,12 @@ export function gridIconBlock(scene, actor, room, rooms) {
                 return line;
             // Box-drawing, so the last child closes the branch and the eye can
             // see where the WAN ends.
-            const kids = slaved.map((i, idx) => `  {light-blue-fg}${idx === slaved.length - 1 ? '└─' : '├─'} ${i}{/light-blue-fg}`);
+            const kids = slaved.map((i, idx) => `  {light-blue-fg}${idx === slaved.length - 1 ? '└─' : '├─'} ${mark(i)}{/light-blue-fg}`);
             return [line, ...kids].join('\n');
         }).join('\n')}`
         : `{light-blue-fg}Nothing overhead -- no host stands over this district.{/light-blue-fg}`);
     out.push(loose.length > 0
-        ? `{light-blue-fg}ICONS IN REACH${slaved.length > 0 ? ' -- answering to nobody up there' : ''}:{/light-blue-fg}\n${loose.map(i => `  {light-blue-fg}${i}{/light-blue-fg}`).join('\n')}`
+        ? `{light-blue-fg}ICONS IN REACH${slaved.length > 0 ? ' -- answering to nobody up there' : ''}:{/light-blue-fg}\n${loose.map(i => `  {light-blue-fg}${mark(i)}{/light-blue-fg}`).join('\n')}`
         : slaved.length > 0
             ? `{light-blue-fg}Nothing else near -- everything around you hangs off the host.{/light-blue-fg}`
             : `{light-blue-fg}Nothing near -- background noise around your signal.{/light-blue-fg}`);

package/bundle/typescript/src/commands/game/sideQuest/utilities/repro-boot.js

@@ -0,0 +1,62 @@
+import { buildReproScene, reproArchetypeName } from '../factories/repro-scene.js';
+import { saveForArchetype } from '../headless-harness.js';
+import { REPRO_ACTOR, reproFixtureOf } from '../types/repro.js';
+/**
+ * The scene and the runner a bench starts with.
+ */
+export function buildReproBoot(repro) {
+    const fixture = reproFixtureOf(repro);
+    const build = buildReproScene(fixture);
+    const archetype = reproArchetypeName(fixture);
+    return {
+        fixture,
+        build,
+        seed: build.seed,
+        archetype,
+        save: saveForArchetype(REPRO_ACTOR, archetype),
+        warnings: build.warnings,
+    };
+}
+/**
+ * THE KNOBS THE SEED CANNOT CARRY, applied to a booted session.
+ *
+ * Call this after the session is up and before the first step (or, on
+ * the site, before the first status push) -- the point of both knobs is
+ * that the bench OPENS on a runner already in that state, so a reporter
+ * reads the condition on their first look rather than watching it be
+ * applied.
+ *
+ * Silent when the fixture asks for neither, and silent when the actor is
+ * missing: a bench whose runner did not boot has a larger problem than
+ * its damage boxes, and it will say so in the transcript.
+ */
+export async function applyReproFixtureState(game, fixture, actorName = REPRO_ACTOR) {
+    // START WOUNDED (fixture.wounded): the boxes go on before the first
+    // step, so the transcript opens on a runner who already needs the
+    // verb under test.
+    if (fixture.wounded) {
+        const runner = game.scene.getPlayerByName(actorName);
+        if (runner) {
+            if (fixture.wounded.physical)
+                runner.takeDamage(fixture.wounded.physical);
+            if (fixture.wounded.stun)
+                runner.takeStun(fixture.wounded.stun);
+        }
+    }
+    // NUYEN (fixture.nuyen): a credstick in the pack, because money lives
+    // on a carrier item (Player.currency sums them) and the pregen has none.
+    if (fixture.nuyen && fixture.nuyen > 0) {
+        const runner = game.scene.getPlayerByName(actorName);
+        if (runner) {
+            const { ItemFactory } = await import('../factories/item-factory.js');
+            const stick = await new ItemFactory().createItemFromJson({
+                name: 'Certified Credstick', description: 'Cash that does not ask questions.',
+                size: 'Tiny', category: 'Credstick', shape: 'Slab', color: 'Black', texture: 'Plastic',
+                rating: 'Common', weight: 0.1, transferable: true,
+            });
+            stick.addCurrency(fixture.nuyen);
+            runner.addInventory(stick);
+        }
+    }
+}
+//# sourceMappingURL=repro-boot.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/repro-launch.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import { fetchReviewQueue } from './backlog.js';
+import { REPRO_ACTOR } from '../types/repro.js';
 /**
  * Resolve `<id>` or `<n>` against a FRESH review queue.
  *
@@ -157,8 +158,14 @@ export function readReproFile(candidate) {
  * since the last step and print them under the output they explain.
  */
 /** The bench's actor. One name, used for the seat and for the
- *  visibility filter below. */
-export const REPRO_ACTOR = 'Tester';
+ *  visibility filter below.
+ *
+ *  Defined in types/repro.ts and re-exported here so the many callers
+ *  that import it from the launcher keep working. It had to move: the
+ *  site needs the same constant, and a module that reaches it through
+ *  anything importing the scene builder would drag the game graph back
+ *  across this file's lazy boundary. See the note on the constant. */
+export { REPRO_ACTOR };
 const stripTags = (s) => s.replace(/\{\/?[a-z-]+\}/g, '');
 /**
  * ONE STEP OF TRANSCRIPT, pure: the command's return string, then what
@@ -221,49 +228,23 @@ export function renderStepLines(step, text, fresh, actor = REPRO_ACTOR) {
     return lines;
 }
 export async function dryRunRepro(repro) {
-    const [{ buildReproScene, reproArchetypeName }, { bootSession, saveForArchetype }] = await Promise.all([
-        import('../factories/repro-scene.js'),
+    // The scene, the runner and the post-boot knobs all come from
+    // repro-boot, which is the ONE definition of what a bench boots as --
+    // shared with maka-cli.com's live bench so the transcript below and
+    // the session a reporter types into cannot describe different
+    // scenarios. See that module's header.
+    const [{ buildReproBoot, applyReproFixtureState }, { bootSession }] = await Promise.all([
+        import('./repro-boot.js'),
         import('../headless-harness.js'),
     ]);
-    const fixture = { ...(repro.fixture ?? {}) };
-    // The reader's framing doubles as the bench's story when the fixture
-    // has none of its own -- one sentence, written once.
-    if (!fixture.premise && repro.premise)
-        fixture.premise = repro.premise;
-    const built = buildReproScene(fixture);
+    const built = buildReproBoot(repro);
     const events = [];
     const session = await bootSession({
         seed: built.seed,
-        players: [saveForArchetype(REPRO_ACTOR, reproArchetypeName(fixture))],
+        players: [built.save],
         events,
     });
-    // START WOUNDED (fixture.wounded): the boxes go on before the first
-    // step, so the transcript opens on a runner who already needs the
-    // verb under test.
-    if (fixture.wounded) {
-        const runner = session.game.scene.getPlayerByName(REPRO_ACTOR);
-        if (runner) {
-            if (fixture.wounded.physical)
-                runner.takeDamage(fixture.wounded.physical);
-            if (fixture.wounded.stun)
-                runner.takeStun(fixture.wounded.stun);
-        }
-    }
-    // NUYEN (fixture.nuyen): a credstick in the pack, because money lives
-    // on a carrier item (Player.currency sums them) and the pregen has none.
-    if (fixture.nuyen && fixture.nuyen > 0) {
-        const runner = session.game.scene.getPlayerByName(REPRO_ACTOR);
-        if (runner) {
-            const { ItemFactory } = await import('../factories/item-factory.js');
-            const stick = await new ItemFactory().createItemFromJson({
-                name: 'Certified Credstick', description: 'Cash that does not ask questions.',
-                size: 'Tiny', category: 'Credstick', shape: 'Slab', color: 'Black', texture: 'Plastic',
-                rating: 'Common', weight: 0.1, transferable: true,
-            });
-            stick.addCurrency(fixture.nuyen);
-            runner.addInventory(stick);
-        }
-    }
+    await applyReproFixtureState(session.game, built.fixture);
     const lines = [];
     // THE FIRST PAINT IS NOT PART OF STEP ONE. bootSession pushes every
     // player's panels the moment the session comes up (B7NNNesy5gvRSbZpp),

package/bundle/typescript/src/commands/game/sideQuest/utilities/silent-icons.js

@@ -1,7 +1,6 @@
 import { rollPool, formatRoll } from './dice.js';
 import { deviceDefensePool } from './matrix-intrusion.js';
 import { isWatched } from './surveillance.js';
-import { DEFAULT_DEVICE_RATING } from '../models/device.js';
 function hiddenDevice(device) {
     return {
         name: device.name,
@@ -34,25 +33,27 @@ export function hiddenIconsIn(scene, room, viewer) {
         .map(hiddenDevice);
     // THE CAMERAS, which p.217 names FIRST. They are not a Device -- the
     // cluster is derived from the room (surveillance.ts isWatched) -- so
-    // they hide on the room's own set, and they hide behind their OWN
-    // rating: an ordinary fixture, which canon prices at 2 (p.356).
+    // the rating rides the ROOM (Room.cameraRating), seeded per site.
     //
     // THE FIRST CUT GAVE THEM THEIR MASTER HOST'S RATING and that was
     // wrong twice over. Canon first: p.233's slaving rule is about what a
-    // slave DEFENDS AN ATTACK with -- "whenever a slaved device is called
-    // on to make a defense test" -- and hiding is not an attack being
-    // defended. Borrowing the host's numbers here was an extrapolation
-    // with nothing under it, which is exactly what this project's rule
-    // against inventing canon is for. And then arithmetic: a rating-8
-    // host gave its lenses 16 dice against a sweep the Data Processing
-    // limit caps near 5, so a camera on any corporate host was not hard
-    // to find, it was impossible. Measured before shipping the fix --
-    // zero finds in twelve looks.
+    // slave DEFENDS AN ATTACK with, and hiding is not an attack being
+    // defended. Then arithmetic: a rating-8 host gave its lenses 16 dice
+    // against a sweep the Data Processing limit caps near 5, so a camera
+    // on any corporate host was not hard to find, it was impossible --
+    // measured at zero finds in twelve looks.
+    //
+    // THE SECOND CUT hard-coded a 4 in here, which fixed the arithmetic
+    // and left the engine holding THREE answers to one question: this
+    // hid behind 4, commands/disable.ts defended a Data Spike with the
+    // HOST's pool, and the icon line showed no rating at all. A player
+    // could not have reconciled them because two of the three were never
+    // printed. One seeded number feeds all three now, so what the player
+    // reads is what it rolls (reporter's ruling: per-site, not global).
     if (isWatched(room) && !room.camerasSpottedBy.has(viewer.name)) {
-        const rating = DEFAULT_DEVICE_RATING.lock ?? 2;
         out.push({
             name: 'Camera cluster',
-            hide: { pool: Math.max(0, rating * 2), label: 'Device Rating' },
+            hide: { pool: Math.max(0, room.cameraRating * 2), label: 'Device Rating + Firewall' },
             reveal: (v) => { room.camerasSpottedBy.add(v); },
         });
     }
@@ -98,28 +99,44 @@ export function spotHiddenIcons(scene, actor, room) {
         + actor.matrixActionPenalty + actor.woundModifier - actor.sustainingPenalty);
     const roll = rollPool(pool, actor.matrixAttribute('dataProcessing'), { gremlins: actor.deckGremlins });
     const found = [];
-    const missed = [];
+    let missed = 0;
     const against = [];
     for (const icon of hidden) {
         const resist = rollPool(icon.hide.pool);
-        against.push({ name: icon.name, label: icon.hide.label, roll: resist });
         // Ties go to the hider: "on a tie or more hits by the defender, it
         // stays hidden and out of reach" (p.236).
         if (roll.hits > resist.hits) {
             icon.reveal(actor.name);
             found.push(icon.name);
+            against.push({ name: icon.name, label: icon.hide.label, roll: resist });
         }
         else {
-            missed.push(icon.name);
+            missed += 1;
+            // THE NAME DOES NOT LEAVE THIS BRANCH. Only the dice do -- see
+            // ISpotOutcome.missed. Attaching the name here "just for the
+            // mechanics line" is exactly how it leaked the first time.
+            against.push({ roll: resist });
         }
     }
     return { found, missed, roll, against };
 }
-/** The mechanics lines for a sweep, for a screen that shows them. */
+/**
+ * The mechanics lines for a sweep.
+ *
+ * AN ICON YOU DID NOT BEAT IS NOT NAMED HERE (user ruling 2026-09-16).
+ * Your own roll is always shown -- it is yours. What it was rolled
+ * against is shown only where you won it: a loss prints its dice and
+ * calls the roller "something", because naming it would hand over for
+ * free precisely what the opposed test exists to charge for (p.235:
+ * the type of an icon and its device rating are things a Matrix
+ * Perception HIT buys).
+ */
 export function spotMechanics(outcome) {
     return [
         `Matrix Perception, silent icons (Computer + Intuition [Data Processing]): ${formatRoll(outcome.roll)}`,
-        ...outcome.against.map(a => `  ${a.name} hides (${a.label}): ${formatRoll(a.roll)}`),
+        ...outcome.against.map(a => (a.name
+            ? `  ${a.name} hides (${a.label}): ${formatRoll(a.roll)}`
+            : `  something holds its cover: ${formatRoll(a.roll)}`)),
     ];
 }
 /**
@@ -135,10 +152,14 @@ export function spotLine(outcome) {
     if (outcome.found.length > 0) {
         lines.push(`You pick ${outcome.found.length === 1 ? 'an icon' : `${outcome.found.length} icons`} out of the noise -- ${outcome.found.join(', ')}, running silent and not quiet enough.`);
     }
-    if (outcome.missed.length > 0) {
-        lines.push(outcome.missed.length === 1
+    if (outcome.missed > 0) {
+        // A COUNT AND NOTHING ELSE. You learn that the room is holding
+        // something back -- which is what a hit buys under p.235-236 -- and
+        // not what it is. `missed` is a number precisely so this line cannot
+        // grow a name later.
+        lines.push(outcome.missed === 1
             ? `Something else here is running silent and you cannot pin it -- a shape in the static that stops when you look at it. (Look again; each sweep is its own Matrix Perception, p.241.)`
-            : `${outcome.missed.length} more icons are running silent here, and none of them will hold still. (Look again; each sweep is its own Matrix Perception, p.241.)`);
+            : `${outcome.missed} more icons are running silent here, and none of them will hold still. (Look again; each sweep is its own Matrix Perception, p.241.)`);
     }
     return lines.join('\n');
 }

package/bundle/typescript/src/commands/game/sideQuest.sub.cmd.js

@@ -6,6 +6,10 @@ import { Actions } from '../../tools/actions/actions.class.js';
 import { Log } from '../../tools/log/log.class.js';
 import { AI } from '../../tools/ai/ai.class.js';
 import { spawnSelf } from '../../tools/self-spawn/self-spawn.js';
+// A value import, not a type-only one, for reproFixtureOf -- safe
+// against this file's "no game graph on `maka --help`" rule because
+// types/repro.ts reaches only two leaf enum modules.
+import { reproFixtureOf } from './sideQuest/types/repro.js';
 /**
  * SPAWN THE GAME AND BE ITS JANITOR.
  *
@@ -77,9 +81,12 @@ export async function spawnGame(launchFilePath, logFilePath) {
  */
 async function launchReproBench(repro, item, makaDir) {
     const { buildReproScene, reproArchetypeName } = await import('./sideQuest/factories/repro-scene.js');
-    const fixture = { ...(repro.fixture ?? {}) };
-    if (!fixture.premise && repro.premise)
-        fixture.premise = repro.premise;
+    // The one premise rule, shared with the dry run and the web bench --
+    // see reproFixtureOf. This path stops at the scene: the game rolls the
+    // character itself from `archetype` below, so it deliberately does NOT
+    // go through repro-boot, which would pull the headless harness (and
+    // with it game.ts) into the PARENT process that only spawns the child.
+    const fixture = reproFixtureOf(repro);
     let built;
     try {
         built = buildReproScene(fixture);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.226.0",
+  "version": "5.228.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",