@maka/maka-cli 5.390.0 → 5.392.0

package/bundle/typescript/src/commands/game/sideQuest/factories/catalog-item-seed.js

@@ -0,0 +1,78 @@
+import { Category, Size, Rating } from '../types/shared/item-enum.js';
+import { catalogGear, catalogGearDef, catalogRowFor } from '../utilities/catalog.js';
+import { NPC_EQUIP_CATEGORIES } from '../npc-kits.js';
+/**
+ * A SEED ITEM BY CATALOG SLUG (player-built runs, 2026-10-06: "sourcing
+ * real catalog-backed loot"). `slug` names a gear row on the site's
+ * catalog; the item takes that row's NAME and its physical fields, so
+ * the catalog's stats -- a weapon's DV and AP, a jacket's armor, a
+ * deck's attributes, read by name through catalogRowFor -- reach it, and
+ * its price, availability and legality are the book's. What the seed
+ * still decides is where it is (room / heldBy / atSpot / owner) and how
+ * it is carried.
+ *
+ * EXACT, never fuzzy: catalogGearDef falls back to findCatalogItem, which
+ * is right for a player typing "predator" at a counter and wrong for an
+ * author's saved run -- a near miss would silently swap the gun.
+ *
+ * Throws on an unknown slug, so synthesis (and so the editor's audit)
+ * reports it rather than shipping an empty-handed guard.
+ */
+export function resolveCatalogItemSeed(seed) {
+    if (!seed.slug)
+        return seed;
+    const row = catalogRowFor(seed.slug);
+    const def = row && row.slug === seed.slug ? catalogGearDef(row.slug) : undefined;
+    if (!def) {
+        throw new Error(`items: "${seed.slug}" is not a catalog gear slug -- pick the item from the catalog.`);
+    }
+    return {
+        ...seed,
+        name: def.name,
+        description: seed.description?.trim() ? seed.description : def.description,
+        category: enumKey(Category, def.category),
+        size: enumKey(Size, def.size),
+        rating: enumKey(Rating, def.rating),
+        shape: def.shape,
+        color: def.color,
+        texture: def.texture,
+        weight: def.weight,
+        ...(def.price !== undefined ? { price: def.price } : {}),
+        // A DECK WITH NO CONFIG IS A DECK WITH A ZEROED ARRAY (repro-scene's
+        // catalogSeedFor has the same rule): the identity order unless the
+        // author set one (p.227).
+        ...(def.category === Category.Cyberdeck && !seed.deckOrder ? { deckOrder: [0, 1, 2, 3] } : {}),
+    };
+}
+function enumKey(e, value) {
+    const entries = e;
+    return Object.keys(entries).find(k => entries[k] === value) ?? 'Unknown';
+}
+/**
+ * THE ITEM VOCABULARY, for an editor's dropdowns: every Category, Size
+ * and Rating key the engine accepts, and which categories the catalog
+ * actually stocks. A category with rows is one a hand-made item may not
+ * claim (the catalog's row is the real thing); one without -- a Key, a
+ * Document, a Badge -- is exactly what a hand-made item is for.
+ */
+export function itemVocabulary() {
+    const stocked = new Map();
+    for (const row of catalogGear()) {
+        const key = String(row.category);
+        stocked.set(key, (stocked.get(key) ?? 0) + 1);
+    }
+    const list = (e) => Object.entries(e)
+        .filter(([k]) => Number.isNaN(Number(k)))
+        .map(([key, label]) => ({ key, label }));
+    return {
+        categories: list(Category).map(c => ({
+            ...c,
+            catalog: stocked.get(c.key) ?? 0,
+            equippable: NPC_EQUIP_CATEGORIES.has(c.label),
+            weapon: c.label === Category.Weapon || c.label === Category.MeleeWeapon || c.label === Category.RangedWeapon,
+        })),
+        sizes: list(Size),
+        ratings: list(Rating),
+    };
+}
+//# sourceMappingURL=catalog-item-seed.js.map

package/bundle/typescript/src/commands/game/sideQuest/factories/job-order.js

@@ -241,31 +241,27 @@ export function parseJobSize(said) {
 }
 // ============================ Requirements ============================
 /**
- * WHAT THIS SITE DEMANDS, read off its structure. Two things a job can
- * ask for that no findable clue or key supplies:
+ * WHAT THIS SITE DEMANDS, read off its structure -- what no findable
+ * clue or key supplies:
  *   - 'decker': the objective is a file on a host. Only a persona
  *     reaches it (a cyberdeck or a living one).
- *   - 'mage': a ward stands on every route from the curb to the prize.
- *     Nothing but the Art unweaves a ward.
  * Locks and panels never count: every one has a key or a clue on the
  * near side (the unconditional clue rule), so any runner gets through.
+ * Nor do wards, any more (user 2026-10-06): a ward is an astral barrier
+ * over a room, and bodies walk through it (p.294, p.315) -- there was a
+ * 'mage' requirement while a ward was a door only the Art opened.
  */
 export function requirementsFor(skeleton) {
     const needs = [];
     const win = skeleton.items.find(i => i.name === skeleton.winCondition?.item);
     if (win?.plane === 'matrix')
         needs.push('decker');
-    const prizeRoom = objectiveRoomFor(skeleton);
-    const start = skeleton.rooms.find(r => r.isStartRoom)?.name;
-    if (prizeRoom && start && !reachableAvoidingWards(skeleton, start, prizeRoom)) {
-        needs.push('mage');
-    }
     return needs;
 }
 /**
  * WHERE THE OBJECTIVE STANDS: the prize item's room (or its holder's),
  * the mark's post, or the target device's room -- whichever the job
- * has. The one answer the lieutenant post, the ward walk and the pay's
+ * has. The one answer the lieutenant post and the pay's
  * "prize room" all read, so a kind added later changes it in one place.
  */
 export function objectiveRoomFor(skeleton) {
@@ -286,45 +282,12 @@ export function objectiveRoomFor(skeleton) {
     }
     return undefined;
 }
-/** Is `to` reachable from `from` without crossing an exit a ward holds?
- *  Edges are two-way, as the engine builds them. A prize room that is
- *  unreachable even WITH wards is the seed validator's problem, not a
- *  mage's -- so it answers true rather than blaming the Art. */
-function reachableAvoidingWards(skeleton, from, to) {
-    const wards = new Set((skeleton.devices ?? []).filter(d => d.kind === 'ward').map(d => d.name));
-    const walk = (skipWards) => {
-        const seen = new Set([from]);
-        const queue = [from];
-        while (queue.length) {
-            const here = queue.shift();
-            if (here === to)
-                return true;
-            for (const room of skeleton.rooms) {
-                for (const exit of room.exits ?? []) {
-                    if (room.name !== here && exit.targetRoom !== here)
-                        continue;
-                    if (skipWards && exit.device && wards.has(exit.device))
-                        continue;
-                    const next = room.name === here ? exit.targetRoom : room.name;
-                    if (!seen.has(next)) {
-                        seen.add(next);
-                        queue.push(next);
-                    }
-                }
-            }
-        }
-        return false;
-    };
-    if (!walk(false))
-        return true;
-    return walk(true);
-}
 /** How Krow says it. Plainly (user ruling): the job's requirement, and
  *  that a crew member covers it. */
 export function requirementLine(needs) {
     if (needs.length === 0)
         return '';
-    const words = needs.map(n => n === 'decker' ? 'a decker' : 'a mage');
+    const words = needs.map(() => 'a decker');
     const list = words.length === 1 ? words[0] : `${words.slice(0, -1).join(', ')} and ${words[words.length - 1]}`;
     return `Straight talk: this one needs ${list}. If that's not you, put one on the crew before you ride.`;
 }

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

@@ -64,12 +64,10 @@ 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,
@@ -79,9 +77,6 @@ const OPPOSITE = {
     [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;
@@ -258,21 +253,24 @@ export function buildReproScene(fixture) {
     }
     if (barrier && !plainDoor) {
         // INVARIANT 1: a code belongs to a panel and nowhere else. The
-        // Device constructor DROPS it on a lock or a ward, silently and
+        // Device constructor DROPS it on a lock, 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.`);
+            throw new ReproFixtureError(`A ${barrier.kind} has no code -- only a panel does. Give it a keyItem, or let it be picked.`);
+        }
+        // A WARD IS NOT A DOOR (user 2026-10-06): it is a room's astral
+        // barrier and stops no body (utilities/wards.ts). A spec still asking
+        // for one on a doorway is describing a game that no longer exists.
+        if (barrier.kind === 'ward') {
+            throw new ReproFixtureError('A ward is not a door barrier any more -- it is an astral barrier over a room, and bodies walk through it. Use a "lock" or a "panel" here.');
         }
         // 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],

package/bundle/typescript/src/commands/game/sideQuest/factories/room-factory.js

@@ -16,6 +16,8 @@ export class RoomFactory {
             isStartRoom: roomJson.isStartRoom,
             roomType: roomJson.roomType,
             outdoors: roomJson.outdoors,
+            ground: roomJson.ground,
+            storeys: roomJson.storeys,
             tags: roomJson.tags ?? [],
             hasNode: roomJson.hasNode,
             nodeAccess: roomJson.nodeAccess,
@@ -25,6 +27,9 @@ export class RoomFactory {
             hostRating: roomJson.hostRating,
             hostGrid: roomJson.hostGrid,
             hostPurpose: roomJson.hostPurpose,
+            hostName: roomJson.hostName,
+            icOrder: roomJson.icOrder,
+            icBricked: roomJson.icBricked,
             hostSculpt: roomJson.hostSculpt,
             // THE INVITATION (p.240; Host.invite). Eaten by this whitelist on
             // 5.243.0's first live walk: the served hub carried hostInvite,
@@ -35,7 +40,14 @@ export class RoomFactory {
             hostInvite: roomJson.hostInvite,
             hostInviteQuality: roomJson.hostInviteQuality,
             warded: roomJson.warded,
+            wardForce: roomJson.wardForce,
+            wardCreator: roomJson.wardCreator,
             watched: roomJson.watched,
+            // Authored lenses (player-built runs) -- named here or this
+            // whitelist eats them, as it ate `owner` and `hostInvite`.
+            cameras: roomJson.cameras,
+            camerasWireless: roomJson.camerasWireless,
+            camerasSlavedTo: roomJson.camerasSlavedTo,
             // The crowd (utilities/crowd.ts) -- named here or this whitelist eats it.
             occupancy: roomJson.occupancy,
             // "At" spots ride through -- this whitelist SILENTLY DROPS any

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

@@ -4,7 +4,8 @@ import { Logger } from '../utilities/logger.js';
 import { catalogAugmentations } from '../utilities/catalog.js';
 import { isOutdoorsPlace } from '../utilities/outdoors.js';
 import { exitContradictions } from '../utilities/district-plane.js';
-import { clampDeviceKind } from '../utilities/affordances.js';
+import { clampDeviceKind, isWardDevice } from '../utilities/affordances.js';
+import { wardDevicesToRooms } from './seed-migration.js';
 import { kitSlugForTier } from '../npc-kits.js';
 import { SIZE_SECURITY_BANDS, SIZE_HOST_BANDS, scopeFor, postsLieutenant, sizeForTier, highestOpposingPool, payFor, rollTwist, requirementsFor, DATA_RUN_SHARE, objectiveRoomFor, isDataCourier, courierMustBeUnseen, } from './job-order.js';
 export { DATA_RUN_SHARE } from './job-order.js';
@@ -464,8 +465,9 @@ routes, and the site should carry a third where it fits -- pick from:
     bribed, or put down;
   * the BACK WAY: a lock or panel on a side door with its key or clue findable elsewhere;
   * the MATRIX WAY: a hasNode host whose maglocks and cameras a persona can take over;
-  * the ASTRAL WAY: a ward on one door only (never on every door), and a spirit or a
-    warded room that a mage reads differently;
+  * the ASTRAL WAY: a warded room ("warded" + "wardForce") -- an astral barrier over the
+    whole room that keeps projecting mages and spirits out but stops NO body -- and the
+    rooms around it a projecting mage can scout freely;
   * the QUIET WAY: a route past sleeping or distracted staff, a service corridor, a roof.
 Never gate the prize behind ONE chokepoint. Never build a route ONLY a decker or ONLY a
 mage could take unless another route exists for everyone else -- but DO build those
@@ -577,7 +579,12 @@ ${JSON_ONLY}
                           // corporate, low-level government. 9-10 regional corporate, secure
                           // sites. 11-12 megacorporate HQ, military command. Rate it for the
                           // place it actually is; omit it and the host is treated as a 3.
-    "warded"?: boolean, // astral barrier: projecting mages can't enter. Use sparingly.
+    "warded"?: boolean, // a WARD over this whole room: an astral barrier that stops
+                         // projecting mages and astral spirits going in OR out. It stops
+                         // NO body and no physical object -- runners walk through it.
+                         // Corporate sites buy them as a cheap contracted service.
+    "wardForce"?: number, // REQUIRED with warded: the ward's Force. 2-3 a small business,
+                          // 4-6 a corporate site, 7+ a megacorporate vault.
     "watched"?: boolean, // security cameras cover this room (feeds ride the site's hosts;
                           // hasNode rooms are always watched implicitly). Use for lobbies,
                           // corridors, and secure floors in corp/guarded locations -- loud
@@ -632,13 +639,14 @@ ${JSON_ONLY}
   }],
   "devices": [{
     "name": string, "concept": string, // what it physically IS (a maglock, a keypad, a
-                                        // scanner, a ward) -- a THING, never a person
+                                        // scanner) -- a THING, never a person, never a ward
+                                        // (a ward is a ROOM's "warded", not a device)
     "room": string, // REQUIRED. A device always stands in ONE room -- the one you must be
                      // in to reach it. If it holds a door, declare that exit FROM THIS
                      // SAME ROOM with "device": "<this name>".
-    "kind": "lock"|"panel"|"ward", // lock = a mechanism: picked, breached, or opened by its
-                          // key. panel = an interface: a code, or hacked. ward = a working:
-                          // cast at or dispelled. EXACTLY these lowercase strings.
+    "kind": "lock"|"panel", // lock = a mechanism: picked, breached, or opened by its
+                          // key. panel = an interface: a code, or hacked. EXACTLY these
+                          // lowercase strings.
                           // A device is always a THING. A doorman or a checkpoint guard is
                           // NOT a device -- write them into npcs[] and name them in that
                           // exit's "guard"; people are got past socially, not picked.
@@ -987,7 +995,7 @@ export function buildDevicesPrompt(skeleton, previousError) {
         return '';
     return `
 You are writing the DEVICES for a Shadowrun text adventure. A device is a THING that is
-shut and can be opened -- a lock, a panel, a ward. Never a person.
+shut and can be opened -- a lock or a panel. Never a person.
 
 ${skeletonContext(skeleton)}
 
@@ -1010,9 +1018,8 @@ fixed, as is its "kind"):
     * Otherwise (an intercom, a voice-gate, a spoken passphrase, a name, a sign reading
       "password") -- ALL LOWERCASE, 2-5 plain words, no punctuation.
   Either way a concrete literal thing, never wordplay.
-  OMIT "code" for a "lock" or a "ward". You cannot talk at a mechanical lock, and a ward
-  answers to the Art -- neither has anything to hear a phrase with, so a code on one is a
-  promise the game cannot keep.
+  OMIT "code" for a "lock". You cannot talk at a mechanical lock -- it has nothing to hear
+  a phrase with, so a code on one is a promise the game cannot keep.
 - "openMessage" / "refuseMessage": one sentence each, in-fiction.
 - "guardsExit": ONLY when the concept is physically TERRAIN blocking a passage -- rubble, a
   collapsed rack, a security shutter across a walkway -- name the exact "direction" of one
@@ -1173,35 +1180,6 @@ export function unwrapChunk(parsed, label) {
     throw new Error(`The "${label}" chunk came back as neither an array nor a { "${CHUNK_ENVELOPE_KEY}": [...] } object.`);
 }
 // ========================= Parse / validate / assemble ====================
-/**
- * Can anyone at this table unweave a WARD?
- *
- * The last surviving branch of what used to be canBypassUnaided, which
- * asked the same question of all three barrier kinds. The other two are
- * gone because their answers stopped mattering (ruling 2026-08-27):
- *
- *   A PANEL takes a code, and a code is FINDABLE. Write it down and any
- *   runner can type it; a decker who did not need it loses nothing.
- *   A LOCK takes a key, and a key is FINDABLE. Place it and any runner
- *   can carry it to the door; picking becomes the SHORTCUT for someone
- *   with locksmith, not the requirement.
- *
- * So for those two the clue/key rule is UNCONDITIONAL now, and the
- * character-dependent waiver is gone with the condition it rested on.
- *
- * A WARD is irreducible. There is no findable answer to a ward; it takes
- * Magic. A mundane team cannot dispel one however much is written down,
- * so a ward generated for a party with nobody awakened is an unopenable
- * barrier no clue can rescue. That is where the character dependence is
- * REAL rather than incidental, and it is the only place this survives.
- *
- * Named for what it now is: a one-case function still called
- * canBypassUnaided would attract the other two cases back.
- */
-export function partyCanDispel(player) {
-    // Adepts are awakened but cannot cast, so they cannot unweave a ward.
-    return !!player && player.isAwakened() && !player.adept;
-}
 /**
  * CAN THIS RUNNER WORK THE GRID AT ALL (ruoedrMTA6kCRNmEN, user ruling:
  * data runs are offered to deck-capable runners only)?
@@ -1487,8 +1465,6 @@ export function validateSkeleton(skeleton, _player, _crew, order) {
                 fail(`device "${device.name}" is the demolition target and also holds a door -- the target is a thing to wreck, not a way through. Give the door its own device.`);
             if (device.grantsItem)
                 fail(`device "${device.name}" is the demolition target and "grantsItem" -- the target opens onto nothing; drop grantsItem.`);
-            if ((device.kind ?? 'panel') === 'ward')
-                fail(`device "${device.name}" is the demolition target and a ward -- a ward is not matter and cannot be wrecked. Make it a "panel" or a "lock".`);
             continue;
         }
         // EVERY WAY THROUGH IS FINDABLE, and it no longer depends on who is
@@ -1549,10 +1525,6 @@ export function validateSkeleton(skeleton, _player, _crew, order) {
                 fail(`lock "${device.name}" ${holdsDoor ? 'holds a door' : 'holds a prize'} and no "key"-role item opens it -- add one with "forDevice": "${device.name}", so a runner without locksmith has a way through.`);
             }
         }
-        // A WARD has no findable answer, and that is now allowed (ruling
-        // 2026-09-24): the prompt asks for a second route past any ward,
-        // and job-order.ts requirementsFor tells Krow to say "you'll need a
-        // mage" when a ward stands on every route to the prize.
     }
     if (skeleton.winCondition.item !== undefined && !itemNames.has(skeleton.winCondition.item))
         fail(`winCondition.item "${skeleton.winCondition.item}" is not in items.`);
@@ -2235,8 +2207,7 @@ export function normalizeSkeleton(skeleton) {
     // protected from being converted into an unplaced reward.
     //
     // PANELS ONLY. A lock's findable way through is its key, not a
-    // written code, and a ward has no findable answer at all (it is
-    // refused outright at validation when nobody can dispel). Synthesis
+    // written code. Synthesis
     // is unconditional for panels now -- there is no waiver left to
     // second-guess, which is what made the old version's log lines need
     // to explain which kind of failure they were.
@@ -2880,6 +2851,9 @@ export function assembleScene(skeleton, details, playerName) {
             hostPurpose: room.hasNode && typeof room.hostPurpose === 'string' ? room.hostPurpose : undefined,
             hostSculpt: room.hasNode && typeof detail?.hostSculpt === 'string' ? detail.hostSculpt : undefined,
             warded: room.warded,
+            // A ward always has a Force; a bad or missing one takes the default
+            // at load (Room WARD_DEFAULT_FORCE) rather than failing the draft.
+            wardForce: room.warded && typeof room.wardForce === 'number' && Number.isFinite(room.wardForce) && room.wardForce >= 1 ? Math.floor(room.wardForce) : undefined,
             watched: room.watched,
             // A headcount or nothing: a bad number falls back to the derived one.
             occupancy: typeof room.occupancy === 'number' && Number.isFinite(room.occupancy) && room.occupancy >= 0 ? Math.round(room.occupancy) : undefined,
@@ -3169,7 +3143,11 @@ export function assembleScene(skeleton, details, playerName) {
         // why, and for the incident (a "tunnel grate" clamped to `panel`
         // and rendered hack-only) that put a name/description-aware
         // fallback here instead of a blind default to `panel`.
-        const kind = clampDeviceKind(device.kind, device.name, detail?.description ?? device.concept);
+        // A WARD WRITTEN AS A DEVICE stays one here, only to be moved onto
+        // its room by wardDevicesToRooms at the end of assembly.
+        const kind = isWardDevice(device.kind, device.name, detail?.description ?? device.concept)
+            ? 'ward'
+            : clampDeviceKind(device.kind, device.name, detail?.description ?? device.concept);
         // A CODE ONLY BELONGS ON A PANEL -- enforced here as well as in the
         // prompt, because the prompt is advice and this is not. You cannot
         // talk at a mechanical lock.
@@ -3190,7 +3168,7 @@ export function assembleScene(skeleton, details, playerName) {
         };
     });
     const startRoom = skeleton.rooms.find(r => r.isStartRoom)?.name ?? skeleton.rooms[0]?.name ?? '';
-    return {
+    return wardDevicesToRooms({
         name: skeleton.name,
         story: skeleton.story,
         currency: { type: 'nuyen', authorityRoomTags: ['Bank'] },
@@ -3254,7 +3232,7 @@ export function assembleScene(skeleton, details, playerName) {
         ...(skeleton.securityTier !== undefined ? { securityTier: skeleton.securityTier } : {}),
         ...(skeleton.neighborhood !== undefined ? { neighborhood: skeleton.neighborhood } : {}),
         ...(skeleton.lawContract ? { lawContract: skeleton.lawContract } : {}),
-    };
+    });
 }
 /**
  * Maps a validation failure to the chunk that owns the broken content, so

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

@@ -5,6 +5,7 @@ import { Door } from '../models/door.js';
 import { RoomFactory } from './room-factory.js';
 import { NPCFactory } from './npc-factory.js';
 import { ItemFactory } from './item-factory.js';
+import { resolveCatalogItemSeed } from './catalog-item-seed.js';
 /** The heaviest a job's prize may be: a Strength 1 runner carries 30 kg
  *  (player.ts maxCarryingWeight), and they still need room for gear. */
 export const OBJECTIVE_MAX_WEIGHT_KG = 15;
@@ -17,6 +18,9 @@ import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { adoptSeededIce } from '../utilities/ic-actors.js';
 import { NPC_EQUIP_CATEGORIES, outfitNpcBySlug } from '../npc-kits.js';
 import { seatHostOwner } from '../utilities/matrix-roster.js';
+import { seatSpider } from '../utilities/spider.js';
+import { cellOnGrid } from '../utilities/room-grid.js';
+import { spotForCell } from '../utilities/spots.js';
 /**
  * How many AI enrichment calls may be in flight at once.
  *
@@ -123,6 +127,31 @@ export class SceneSynthesizer {
         // that has already been migrated (and saved, and reloaded) passes
         // through untouched.
         json = migrateLegacySeed(json);
+        // A CATALOG SLUG IS THE ROW ITSELF (catalog-item-seed.ts): resolved
+        // once, here, so every later step that matches items by name -- heldBy,
+        // ownership, the win condition, keys -- sees the catalog's name. A
+        // seed with no slugs passes through untouched.
+        if ((json.items ?? []).some(i => i.slug)) {
+            json = { ...json, items: json.items.map(resolveCatalogItemSeed) };
+        }
+        // A DEVICE WITH A CELL STANDS THERE (device-seed.ts cell): it gets a
+        // one-cell spot of its own name, and is `at` it. A seed with no
+        // placed device passes through untouched.
+        if ((json.rooms ?? []).some(r => (r.devices ?? []).some(d => d.cell && !d.atSpot))) {
+            json = {
+                ...json,
+                rooms: json.rooms.map(r => {
+                    const placed = (r.devices ?? []).filter(d => d.cell && !d.atSpot);
+                    if (placed.length === 0)
+                        return r;
+                    return {
+                        ...r,
+                        spots: [...(r.spots ?? []), ...placed.map(d => ({ name: d.name, cell: d.cell, size: { w: 1, h: 1 } }))],
+                        devices: (r.devices ?? []).map(d => (d.cell && !d.atSpot ? { ...d, atSpot: d.name } : d)),
+                    };
+                }),
+            };
+        }
         // Step 1: Create the Scene using the JSON’s room configuration
         logger.write(`Initilizing Scene`);
         const scene = new Scene({
@@ -187,6 +216,12 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
                 if (exit.atSpot) {
                     scene.getRoom(roomJson.name)?.exitSpots.set(exit.direction.toLowerCase(), exit.atSpot);
                 }
+                // An authored door or stair position (exit seed `cell`).
+                if (exit.cell) {
+                    const declaring = scene.getRoom(roomJson.name);
+                    if (declaring)
+                        declaring.authoredDoorCells = { ...(declaring.authoredDoorCells ?? {}), [exit.direction.toLowerCase()]: { x: exit.cell.x, y: exit.cell.y } };
+                }
             }
         }
         beat('exits');
@@ -217,6 +252,11 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
             if (npcJson.player.guarding) {
                 npc.guarding = true;
             }
+            // ...and a WATCHED one is guarded without being blocked (utilities/
+            // door-watch.ts): they turn on anyone caught going for it.
+            if (npcJson.player.watches) {
+                npc.watching = String(npcJson.player.watches).toLowerCase();
+            }
             // A MERCHANT'S TRADE (IMerchantSeed): what they sell is authored,
             // not read off whatever happens to lie in their room.
             if (npcJson.merchant) {
@@ -290,8 +330,18 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
         // Step 4: Add Items
         const itemFactory = new ItemFactory();
         const itemMap = new Map();
+        /** Weapons and armor an author asked to keep holstered / packed
+         *  (IItemSeedJson.equipped === false) -- read at Step 4.05. */
+        const carryAs = new Map();
         for (const itemJson of json.items ?? []) {
             const item = await itemFactory.createItemFromJson(itemJson);
+            if (typeof itemJson.equipped === 'boolean')
+                carryAs.set(item, itemJson.equipped);
+            // A FILE'S OWN DEFENCES (utilities/file-guard.ts), authored only.
+            if (itemJson.protection && itemJson.protection > 0)
+                item.protection = itemJson.protection;
+            if (itemJson.dataBomb && itemJson.dataBomb.rating > 0)
+                item.dataBomb = { ...itemJson.dataBomb };
             // THE PRIZE HAS TO BE CARRIABLE (KSfzQzuHTx7kHjohi, 2026-09-12:
             // "I shouldn't have an item I need to return, that I can't carry
             // -- this case is too heavy"). The seed's items are written by a
@@ -556,6 +606,48 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
                 logger.error(`Scene "${json.name}": the door ${String(direction)} of ${room.name} was locked by "${wanted ?? '(nothing)'}", which no device holds and no item matches -- it ships unlocked rather than as a wall.`);
             }
         }
+        // Step 4.96: AUTHORED START CELLS (player-built runs, 2026-10-06). An
+        // NPC with `startCell` stands exactly there. HERE, not at Step 3 where
+        // they were placed: spotForCell builds the room's grid, and a grid
+        // built before the device step above (4.9) would be frozen without
+        // the rubble its terrain hints add. The spot comes from `startSpot`
+        // when the author gave one, otherwise from whatever the cell touches.
+        for (const npcJson of json.npcs ?? []) {
+            const at = npcJson.player.startCell;
+            if (!at)
+                continue;
+            const npc = scene.getActor(npcJson.player.name);
+            const room = npc?.currentLocation;
+            if (!npc || !room?.ensureGrid())
+                continue;
+            const cell = { x: Math.round(at.x), y: Math.round(at.y), z: Math.round(at.z ?? 0) };
+            if (!cellOnGrid(room.ensureGrid(), cell)) {
+                logger.error(`Scene "${json.name}": ${npc.name}'s startCell ${cell.x},${cell.y} is off ${room.name}'s grid -- left to their spot.`);
+                continue;
+            }
+            npc.atSpot = npcJson.player.startSpot ?? spotForCell(room, cell);
+            npc.atCell = cell;
+        }
+        // ...and items lying where the author put them (items[].cell). An
+        // item may sit ON furniture -- the file on the desk -- so the cell is
+        // not checked against footprints; reach goes through the spot it
+        // touches, exactly as for a body standing there.
+        for (const itemJson of json.items ?? []) {
+            const at = itemJson.cell;
+            if (!at || !itemJson.room)
+                continue;
+            const item = itemMap.get(itemJson.name);
+            const room = scene.getRoom(itemJson.room);
+            if (!item || !room?.ensureGrid())
+                continue;
+            const cell = { x: Math.round(at.x), y: Math.round(at.y), z: Math.round(at.z ?? 0) };
+            if (!cellOnGrid(room.ensureGrid(), cell)) {
+                logger.error(`Scene "${json.name}": "${item.name}" cell ${cell.x},${cell.y} is off ${room.name}'s grid -- left unplaced.`);
+                continue;
+            }
+            item.atCell = cell;
+            item.atSpot = itemJson.atSpot ?? spotForCell(room, cell);
+        }
         // Step 4.04: NPCs get their kit (npc-kits.ts, SR5 p.379-385, catalog
         // v21). AFTER "heldBy" has landed (Step 4.5 above -- the numbering is
         // historical, the source order is what runs) and BEFORE the equip
@@ -600,8 +692,12 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
             if (!npc)
                 continue;
             for (const item of [...npc.inventory.getAllItems()]) {
+                // Only weapons and armor are ever equipped -- a key is carried,
+                // never wielded -- and an author may keep one of those holstered.
                 if (!NPC_EQUIP_CATEGORIES.has(item.category))
                     continue;
+                if (carryAs.get(item) === false)
+                    continue;
                 if (weaponCategories.has(item.category) && npc.getCarriedWeapon())
                     continue;
                 try {
@@ -728,6 +824,22 @@ Key Locations: ${json.rooms.map(r => r.name).join(', ')}
             if (seated)
                 logger.write(`"${seated.name}" works the host over "${room.name}" -- his icon is inside it.`);
         }
+        // Step 7c: SPIDERS (utilities/spider.ts). After 7b, so a host owner
+        // who is also its spider ends up in VR rather than AR; after 4.96 and
+        // the gear steps, so the body slumps at its authored cell with its
+        // deck in hand. A refusal leaves them in the meat -- the authored
+        // audit reports the same refusal as a fault.
+        for (const npcJson of json.npcs ?? []) {
+            const into = npcJson.player.jackedInto;
+            if (!into)
+                continue;
+            const npc = scene.getActor(npcJson.player.name);
+            const host = scene.getRoom(into)?.host;
+            if (!npc || !host)
+                continue;
+            const refused = seatSpider(scene, npc, host, npcJson.player.sim ?? 'cold');
+            logger.write(refused ? `Spider "${npc.name}" stays in the meat: ${refused}` : `"${npc.name}" is jacked into ${host.name} (${npc.simMode}-sim).`);
+        }
         // JACKPOINT, IN EVERY SCENE (qgyKnJLSeoxMf23j8). A standing host has
         // to be reachable from wherever the runner is, and Scene.getRooms()
         // is the whole reachable universe -- so the haven is added to each