@maka/maka-cli 5.391.0 → 5.392.0

package/bundle/typescript/src/commands/game/sideQuest/factories/authored-run.js

@@ -0,0 +1,632 @@
+import { wallFixtureKindOf } from '../utilities/room-grid.js';
+import { roomGridWire } from '../utilities/ways-out.js';
+import { icTypeNamed, IC_TYPES, resolveICOrder } from '../utilities/ic.js';
+import { deviceMaster } from '../utilities/wan.js';
+import { isWatched, lensMaster, lensBroadcasts } from '../utilities/surveillance.js';
+import { BIG_TEN } from '../utilities/grids.js';
+import { roomAtCell } from '../utilities/district-plane.js';
+import { kitSlugForTier } from '../npc-kits.js';
+import { SceneSeedGenerator } from './scene-seed-generator.js';
+import { VAULT_HOST_RATING } from './scene-chunks.js';
+import { SIZE_SECURITY_BANDS, postsLieutenant, highestOpposingPool, payFor } from './job-order.js';
+import { itemVocabulary } from './catalog-item-seed.js';
+import { catalogRowFor } from '../utilities/catalog.js';
+import { spiderRefusal, spidersIn } from '../utilities/spider.js';
+import { NPC } from '../models/npc.js';
+export { itemVocabulary };
+/**
+ * THE BOOK'S NUMBERS, written over whatever the author put (SR5
+ * p.371-372, p.379-385). Works on a copy.
+ *
+ *  - securityTier is clamped to the job size's Professional Rating band.
+ *  - Every hostile (not the client) carries the tier's npc-kit, and its
+ *    `combat` block is dropped: THE KIT IS THE STATLINE, as assembleScene
+ *    rules for generated runs. From medium up one of them is posted as
+ *    the lieutenant (p.380-381), preferring one in the prize's room.
+ *  - The payout is payFor's, for `heads` runners.
+ *
+ * `heads` is the table's runner count -- known at launch; the editor's
+ * preview quotes it for one.
+ */
+export function prepareAuthoredSeed(seed, heads = 1) {
+    const out = structuredClone(seed);
+    const notes = [];
+    const size = out.jobSize ?? 'small';
+    out.jobSize = size;
+    const band = SIZE_SECURITY_BANDS[size];
+    const declared = out.securityTier;
+    const tier = Math.max(band.min, Math.min(band.max, Number.isFinite(declared) ? Math.round(declared) : band.min));
+    if (declared !== tier)
+        notes.push(`securityTier ${declared ?? 'absent'} -> ${tier} (a ${size} job fields PR ${band.min === band.max ? band.min : `${band.min}-${band.max}`}).`);
+    out.securityTier = tier;
+    const npcs = (out.npcs ?? []).map(n => n.player);
+    const hostiles = npcs.filter(p => p.hostile === true && p.name !== out.client);
+    const winItem = (out.items ?? []).find(i => i.name === out.winCondition?.item);
+    const prizeRoom = out.winCondition?.target ?? winItem?.room;
+    const lieutenant = postsLieutenant(size) && hostiles.length > 0
+        ? (hostiles.find(p => prizeRoom !== undefined && p.startLocation === prizeRoom) ?? hostiles[0])
+        : undefined;
+    const kit = kitSlugForTier(tier);
+    for (const p of npcs) {
+        delete p.lieutenant;
+        if (!hostiles.includes(p))
+            continue;
+        // A SPIDER KEEPS THE AUTHOR'S STATLINE: no tier kit below the p.384
+        // elite lieutenant carries a deck or a Matrix skill, so stamping one
+        // would leave a decker who cannot hack (utilities/spider.ts). Until
+        // NPC sheets arrive, their `combat` block is what they hack with.
+        if (kit && !p.jackedInto) {
+            p.kit = kit;
+            delete p.combat;
+        }
+        if (p === lieutenant)
+            p.lieutenant = true;
+    }
+    // A data run's opposition is the vault host's IC (Host Rating x 2,
+    // p.247-248); a physical job's is the tier's statblock.
+    const vaultName = winItem?.plane === 'matrix' ? (out.winCondition?.target ?? winItem.room) : undefined;
+    const vault = vaultName ? (out.rooms ?? []).find(r => r.name === vaultName) : undefined;
+    const pool = vault ? 2 * (vault.hostRating ?? VAULT_HOST_RATING) : highestOpposingPool(tier, lieutenant !== undefined);
+    if (out.winCondition) {
+        const wrote = out.winCondition.payout;
+        const payout = payFor({
+            pool, heads: Math.max(1, heads), hostiles: hostiles.length, securityTier: tier,
+            dangerous: !!out.twist, wetwork: out.jobKind === 'assassination',
+        });
+        out.winCondition.payout = payout;
+        if (wrote !== undefined && wrote !== payout)
+            notes.push(`payout ${wrote} -> ${payout} (p.371).`);
+    }
+    return { seed: out, notes };
+}
+/** The rooms a fault's text names, longest name first so "Kettle Row
+ *  Walk-Up" is not also read as "Kettle Row". */
+function roomsNamed(message, seed) {
+    const names = (seed.rooms ?? []).map(r => r?.name).filter((n) => typeof n === 'string' && n.length > 0)
+        .sort((a, b) => b.length - a.length);
+    const found = [];
+    let rest = message;
+    for (const name of names) {
+        if (!rest.includes(name))
+            continue;
+        found.push(name);
+        rest = rest.split(name).join(' ');
+    }
+    return found;
+}
+/**
+ * WHAT AN AUTHOR'S ITEMS MUST BE (user 2026-10-06: "non-catalog items
+ * still need a category"). Authored runs only -- a generated seed's
+ * props are the generator's business. A hand-made item names a real
+ * engine Category; and a category the catalog stocks is not one a
+ * hand-made item may claim, because the catalog's row is the real thing
+ * (its stats, price and legality are the book's).
+ */
+export function authoredItemFaults(seed) {
+    const vocab = itemVocabulary();
+    const byKey = new Map(vocab.categories.map(c => [c.key, c]));
+    const faults = [];
+    const rooms = new Map((seed.rooms ?? []).map(r => [r.name, r]));
+    for (const item of seed.items ?? []) {
+        const where = item.room ? [item.room] : [];
+        // AN ITEM LYING IN A ROOM LIES SOMEWHERE (user 2026-10-06: "I should
+        // be able to place items on the grid too"). Held items ride with their
+        // holder; paydata lives in the Matrix and has no floor.
+        const label = item.name ?? item.slug;
+        const room = item.room ? rooms.get(item.room) : undefined;
+        if (room && !item.heldBy && (item.plane ?? 'meat') === 'meat') {
+            if (!item.cell) {
+                faults.push({ check: 'coords', message: `"${label}" is not placed in "${room.name}" -- drag it onto its grid.`, rooms: where });
+            }
+            else if (room.footprint && (item.cell.x < 0 || item.cell.y < 0 || item.cell.x >= room.footprint.w || item.cell.y >= room.footprint.h)) {
+                faults.push({ check: 'coords', message: `"${label}" lies outside "${room.name}" (${item.cell.x},${item.cell.y}).`, rooms: where });
+            }
+        }
+        // HOLSTERED IS FOR WEAPONS AND ARMOR. A key is carried, never wielded.
+        if (item.equipped !== undefined) {
+            const key = item.slug ? catalogRowFor(item.slug)?.category : String(item.category);
+            if (key && byKey.get(key) && !byKey.get(key).equippable) {
+                faults.push({ check: 'items', message: `"${item.name ?? item.slug}" is not a weapon or armor -- it cannot be held in hand, worn or holstered.`, rooms: where });
+            }
+        }
+        // DATA LIVES ON A HOST, never in a pocket (scene-chunks' vault rule):
+        // a matrix-plane item sits in a room with a host, held by nobody.
+        if (item.plane === 'matrix') {
+            if (item.heldBy || !room?.hasNode) {
+                faults.push({ check: 'items', message: `"${label}" is host data but is not on a host -- put it on a room that has one.`, rooms: where });
+            }
+        }
+        // A FILE'S OWN DEFENCES (utilities/file-guard.ts) are for files: Edit
+        // File protects one (p.239) and a data bomb sits on one (p.242).
+        if (item.protection !== undefined || item.dataBomb !== undefined) {
+            if (item.plane !== 'matrix') {
+                faults.push({ check: 'items', message: `"${label}" is not host data -- only a file can be protected or carry a data bomb.`, rooms: where });
+            }
+            if (item.protection !== undefined && !(Number.isInteger(item.protection) && item.protection >= 1 && item.protection <= 12)) {
+                faults.push({ check: 'items', message: `"${label}"'s protection must be a whole rating from 1 to 12.`, rooms: where });
+            }
+            const bomb = item.dataBomb;
+            if (bomb && !(Number.isInteger(bomb.rating) && bomb.rating >= 1 && bomb.rating <= 12)) {
+                faults.push({ check: 'items', message: `"${label}"'s data bomb needs a whole rating from 1 to 12.`, rooms: where });
+            }
+        }
+        if (item.slug)
+            continue;
+        const cat = byKey.get(String(item.category));
+        if (!cat) {
+            faults.push({ check: 'items', message: `"${item.name}" has no real category ("${String(item.category ?? '')}") -- pick one.`, rooms: where });
+        }
+        else if (cat.catalog > 0) {
+            faults.push({ check: 'items', message: `"${item.name}" is a hand-made ${cat.label} -- the catalog stocks ${cat.catalog} of those; pick it from the catalog instead.`, rooms: where });
+        }
+    }
+    return faults;
+}
+/**
+ * FURNITURE IS WHERE THE AUTHOR PUTS IT (user 2026-10-06: "we shouldn't
+ * have the engine draw spots on its own"). In a hand-built run every spot
+ * carries its cells; one without them is a fault, not a cue for the grid
+ * to guess. Doors and windows are prose (wallFixtureKindOf) and need none.
+ */
+export function authoredSpotFaults(seed) {
+    const faults = [];
+    for (const room of seed.rooms ?? []) {
+        for (const spot of room.spots ?? []) {
+            if (spot.cell || wallFixtureKindOf(spot.name))
+                continue;
+            faults.push({ check: 'coords', message: `"${spot.name}" in "${room.name}" is not placed -- draw it on the room's grid.`, rooms: [room.name] });
+        }
+    }
+    return faults;
+}
+/**
+ * EVERY BODY IS WHERE THE AUTHOR PUT IT. An NPC in the meat starts at a
+ * cell of its room (player.startCell); one without is a fault, and so is
+ * a cell outside the room's footprint. IC and spirits live on other
+ * planes and have no floor cell.
+ */
+export function authoredNpcFaults(seed) {
+    const faults = [];
+    const rooms = new Map((seed.rooms ?? []).map(r => [r.name, r]));
+    for (const npc of seed.npcs ?? []) {
+        if ((npc.plane ?? 'meat') !== 'meat')
+            continue;
+        const p = npc.player;
+        const room = p.startLocation ? rooms.get(p.startLocation) : undefined;
+        const where = room ? [room.name] : [];
+        // A WATCHED DOOR is one of their own room's ways out (door-watch.ts).
+        const watches = p.watches;
+        if (room && watches && !(room.exits ?? []).some(e => String(e.direction).toLowerCase() === watches.toLowerCase())) {
+            faults.push({ check: 'coords', message: `${p.name} watches the ${watches} door of "${room.name}", which has none.`, rooms: where });
+        }
+        if (!room) {
+            faults.push({ check: 'coords', message: `${p.name} is in no room -- drag them onto a room's grid.`, rooms: where });
+        }
+        else if (!p.startCell) {
+            faults.push({ check: 'coords', message: `${p.name} is not placed in "${room.name}" -- drag them onto its grid.`, rooms: where });
+        }
+        else if (room.footprint && (p.startCell.x < 0 || p.startCell.y < 0
+            || p.startCell.x >= room.footprint.w || p.startCell.y >= room.footprint.h)) {
+            faults.push({ check: 'coords', message: `${p.name} stands outside "${room.name}" (${p.startCell.x},${p.startCell.y}).`, rooms: where });
+        }
+    }
+    return faults;
+}
+/**
+ * CAMERAS AND DEVICES WHERE THE AUTHOR PUT THEM. A lens hangs over a
+ * floor cell on the edge of its own wall; a placed device stands inside
+ * its room; anything slaved to a host names a room that has one.
+ */
+export function authoredSecurityFaults(seed) {
+    const faults = [];
+    const hosts = new Set((seed.rooms ?? []).filter(r => r.hasNode).map(r => r.name));
+    for (const room of seed.rooms ?? []) {
+        const fp = room.footprint;
+        const where = [room.name];
+        for (const cam of room.cameras ?? []) {
+            const label = cam.name?.trim() || `the ${cam.wall} camera`;
+            if (!cam.cell) {
+                faults.push({ check: 'coords', message: `${label} in "${room.name}" is not hung -- put it on the room's grid.`, rooms: where });
+            }
+            else {
+                // North and west need no dimensions (row 0, column 0); south and
+                // east are read off the footprint when the room has one.
+                const c = cam.cell;
+                // OUTDOORS THERE IS NO WALL: a lens on a pole or a lamp-post stands
+                // on any cell of the area (user 2026-10-06, placing cameras on the
+                // ground and the strips from the plan).
+                const onWall = room.outdoors || (cam.wall === 'north' ? c.y === 0 : cam.wall === 'west' ? c.x === 0
+                    : !fp || (cam.wall === 'south' ? c.y === fp.h - 1 : c.x === fp.w - 1));
+                const inside = c.x >= 0 && c.y >= 0 && (!fp || (c.x < fp.w && c.y < fp.h));
+                if (!inside || !onWall) {
+                    faults.push({ check: 'coords', message: `${label} in "${room.name}" must hang on its ${cam.wall} wall (${c.x},${c.y} is not on it).`, rooms: where });
+                }
+            }
+            // EVERY CAMERA ANSWERS TO A HOST (user ruling 2026-10-06: "a camera
+            // can't exist on a room/pole with no host -- what's the point?").
+            // Its own link, else the room's, else the room's own host -- and a
+            // pole camera, failing those, the run's site host: the same default
+            // the engine wires (surveillance.ts cameraMasterHost) and the Matrix
+            // layer draws, so the editor never shows a link the audit denies.
+            const siteHost = room.outdoors && !cam.mountedOn ? (seed.rooms ?? []).find(r => r.hasNode)?.name : undefined;
+            // On a building's outside wall: that building's host.
+            const wallHost = cam.mountedOn ? seedBuildingHost(seed, cam.mountedOn) : undefined;
+            const master = cam.slavedTo ?? wallHost ?? room.camerasSlavedTo ?? (room.hasNode ? room.name : siteHost);
+            if (!master && cam.mountedOn) {
+                faults.push({ check: 'security', message: `${label} on the wall of "${cam.mountedOn}" answers to no host -- give "${cam.mountedOn}" a host, or slave the camera to one.`, rooms: [...where, cam.mountedOn] });
+            }
+            else if (!master) {
+                faults.push({ check: 'security', message: room.outdoors
+                        ? `${label} in "${room.name}" is on a pole, and this run has no host for it to answer to -- give a building a host (police hosts are Host Rating 5+; below that it must broadcast).`
+                        : `${label} in "${room.name}" answers to no host -- give the room a host, or slave the camera to one.`, rooms: where });
+            }
+        }
+        // AN OWNER IS SOMEONE: a room's owner names one of the run's NPCs.
+        if (room.owner && !(seed.npcs ?? []).some(n => n.player.name === room.owner)) {
+            faults.push({ check: 'security', message: `"${room.name}" is owned by "${room.owner}", who is not in the cast.`, rooms: where });
+        }
+        // A HOST HAS AN OWNER (user ruling 2026-10-06: "a room with a host
+        // must have an owner"). Someone runs it, knows its codes and answers
+        // for what is done to it (owner-guard.ts, NPC hostCodeNote).
+        if (room.hasNode && !room.owner) {
+            faults.push({ check: 'security', message: `"${room.name}" has a host but no owner -- pick who runs it (ROOM tab, "owner").`, rooms: where });
+        }
+        // THE HOST'S GRID is one the engine resolves (game.ts): public, local,
+        // or a Big Ten corp's global grid (p.233-234).
+        if (room.hostGrid && !gridVocabulary().includes(room.hostGrid)) {
+            faults.push({ check: 'security', message: `"${room.name}"'s host grid "${room.hostGrid}" is not a grid -- public, local, or a Big Ten global grid.`, rooms: where });
+        }
+        // THE IC LINEUP (Data Trails p.91-102): every program one the engine
+        // runs, each once. Canon lineups may be longer than the rating -- the
+        // cap is on programs running at once (p.247) -- so length is not a fault.
+        if (room.icOrder && room.icOrder.length > 0) {
+            if (!room.hasNode) {
+                faults.push({ check: 'security', message: `"${room.name}" lists IC but has no host.`, rooms: where });
+            }
+            const seen = new Set();
+            for (const n of room.icOrder) {
+                const t = icTypeNamed(n);
+                if (!t) {
+                    faults.push({ check: 'security', message: `${n} (in "${room.name}"'s IC) is not one the engine runs yet.`, rooms: where });
+                }
+                else if (seen.has(t.name)) {
+                    faults.push({ check: 'security', message: `${t.name} is listed twice in "${room.name}"'s IC -- a host runs one of each (p.247).`, rooms: where });
+                }
+                else {
+                    seen.add(t.name);
+                }
+            }
+        }
+        if (room.camerasSlavedTo && !hosts.has(room.camerasSlavedTo)) {
+            faults.push({ check: 'security', message: `"${room.name}"'s cameras are slaved to "${room.camerasSlavedTo}", which has no host.`, rooms: where });
+        }
+        // ONE LENS, ITS OWN HOST (surveillance.ts lensMaster).
+        for (const cam of room.cameras ?? []) {
+            if (cam.slavedTo && !hosts.has(cam.slavedTo)) {
+                faults.push({ check: 'security', message: `The ${cam.name ?? `${cam.wall} camera`} in "${room.name}" is slaved to "${cam.slavedTo}", which has no host.`, rooms: where });
+            }
+        }
+        // NO LOCK BETWEEN TWO OUTDOOR SPACES (user 2026-10-06: "outside to
+        // outside links shouldn't have maglocks"): streets that meet share no
+        // wall, so there is no door to lock -- a device, or a keyed exit.
+        const outdoorTo = (dir) => {
+            if (!room.outdoors || !dir)
+                return undefined;
+            const exit = (room.exits ?? []).find(e => String(e.direction).toLowerCase() === dir.toLowerCase());
+            const to = exit ? (seed.rooms ?? []).find(r => r.name === exit.targetRoom) : undefined;
+            return to?.outdoors ? to : undefined;
+        };
+        for (const exit of room.exits ?? []) {
+            const to = outdoorTo(String(exit.direction));
+            if (to && exit.keyRequired) {
+                faults.push({ check: 'security', message: `"${room.name}" ${exit.direction} to "${to.name}" is open ground -- it cannot be locked.`, rooms: [room.name, to.name] });
+            }
+        }
+        for (const dev of room.devices ?? []) {
+            const to = dev.kind === 'lock' ? outdoorTo(dev.opensExit) : undefined;
+            if (to) {
+                faults.push({ check: 'security', message: `${dev.name} locks the way from "${room.name}" to "${to.name}", which is open ground -- there is no door to lock.`, rooms: [room.name, to.name] });
+            }
+            if (dev.slavedTo && !hosts.has(dev.slavedTo)) {
+                faults.push({ check: 'security', message: `${dev.name} is slaved to "${dev.slavedTo}", which has no host.`, rooms: where });
+            }
+            if (dev.cell && fp && (dev.cell.x < 0 || dev.cell.y < 0 || dev.cell.x >= fp.w || dev.cell.y >= fp.h)) {
+                faults.push({ check: 'coords', message: `${dev.name} stands outside "${room.name}" (${dev.cell.x},${dev.cell.y}).`, rooms: where });
+            }
+        }
+    }
+    return faults;
+}
+/**
+ * NOTHING STANDS IN A DOORWAY (user 2026-10-06: "it looks like I can draw
+ * furniture on a wall"). The grid claims every door's cell and the one
+ * cell it is reached from before anything else is placed; an author's
+ * furniture drawn over either seals the door. Read off the BUILT grid, so
+ * it is the engine's own door cells that are checked.
+ */
+/**
+ * A DOOR OPENS ONTO WHAT IS ACTUALLY OUTSIDE IT (user 2026-10-06: "I should
+ * see an error if the exit of a building is to the master grid, but a
+ * street is on top of it"). Where a building's door to an outdoor area
+ * lands, read off the BUILT plane -- the engine's own door cell -- and the
+ * cell just past it must belong to the area the exit names (rooms over
+ * spaces over the ground, district-plane.ts roomAtCell). Otherwise the
+ * door opens onto some other area, and the exit should name that one.
+ */
+/** The building a room belongs to's host, from the seed: its own, else the
+ *  nearest through inside doors and stairs (surveillance.ts buildingHost). */
+function seedBuildingHost(seed, roomName) {
+    const rooms = seed.rooms ?? [];
+    const byName = new Map(rooms.map(r => [r.name, r]));
+    const links = new Map();
+    const link = (a, b) => { (links.get(a) ?? links.set(a, new Set()).get(a)).add(b); };
+    for (const r of rooms)
+        for (const e of r.exits ?? []) {
+            link(r.name, e.targetRoom);
+            link(e.targetRoom, r.name);
+        }
+    const seen = new Set([roomName]);
+    let frontier = [roomName];
+    while (frontier.length > 0) {
+        const hit = frontier.find(n => byName.get(n)?.hasNode);
+        if (hit)
+            return hit;
+        const next = [];
+        for (const n of frontier)
+            for (const m of links.get(n) ?? []) {
+                if (seen.has(m) || byName.get(m)?.outdoors)
+                    continue;
+                seen.add(m);
+                next.push(m);
+            }
+        frontier = next;
+    }
+    return undefined;
+}
+export function authoredDoorstepFaults(seed, built) {
+    const faults = [];
+    if (!built)
+        return faults;
+    const plane = built.ensurePlane();
+    const key = (n) => n.trim().toLowerCase();
+    const OUT = { north: [0, -1], south: [0, 1], west: [-1, 0], east: [1, 0] };
+    for (const room of seed.rooms ?? []) {
+        if (room.outdoors || !room.footprint)
+            continue;
+        const at = plane.placements.get(key(room.name));
+        if (!at)
+            continue;
+        for (const exit of room.exits ?? []) {
+            const dir = String(exit.direction).toLowerCase();
+            const step = OUT[dir];
+            const target = (seed.rooms ?? []).find(r => r.name === exit.targetRoom);
+            if (!step || !target?.outdoors)
+                continue;
+            const local = at.doors?.[dir];
+            if (!local)
+                continue;
+            // The door cell is in the wall ring; its doorstep one cell further out.
+            const ring = dir === 'north' ? { x: at.origin.x + local.x, y: at.origin.y - 1 }
+                : dir === 'south' ? { x: at.origin.x + local.x, y: at.origin.y + at.dims.y }
+                    : dir === 'west' ? { x: at.origin.x - 1, y: at.origin.y + local.y }
+                        : { x: at.origin.x + at.dims.x, y: at.origin.y + local.y };
+            const owner = roomAtCell(plane, { x: ring.x + step[0], y: ring.y + step[1], z: at.origin.z });
+            if (!owner || owner === key(target.name))
+                continue;
+            const ownerName = (seed.rooms ?? []).find(r => key(r.name) === owner)?.name ?? owner;
+            faults.push({
+                check: 'plan',
+                message: `${room.name}'s ${dir} door is linked to "${target.name}" but opens onto "${ownerName}" -- link it to "${ownerName}" (drag from the wall to it).`,
+                rooms: [room.name, ownerName],
+            });
+        }
+    }
+    return faults;
+}
+export function authoredDoorwayFaults(seed, built) {
+    const faults = [];
+    const INWARD = { north: [0, 1], south: [0, -1], west: [1, 0], east: [-1, 0] };
+    for (const seedRoom of seed.rooms ?? []) {
+        const placed = (seedRoom.spots ?? []).filter(s => s.cell);
+        if (placed.length === 0)
+            continue;
+        const grid = built?.getRoom(seedRoom.name)?.ensureGrid();
+        if (!grid)
+            continue;
+        const doorAt = new Map();
+        for (const [dir, c] of grid.exitCells.entries()) {
+            const d = String(dir);
+            if (!INWARD[d] || c.z !== 0)
+                continue;
+            doorAt.set(`${c.x},${c.y}`, d);
+            doorAt.set(`${c.x + INWARD[d][0]},${c.y + INWARD[d][1]}`, d);
+        }
+        for (const spot of placed) {
+            const w = Math.max(1, spot.size?.w ?? 1);
+            const h = Math.max(1, spot.size?.h ?? 1);
+            const hit = new Set();
+            for (let dx = 0; dx < w; dx++)
+                for (let dy = 0; dy < h; dy++) {
+                    const d = doorAt.get(`${spot.cell.x + dx},${spot.cell.y + dy}`);
+                    if (d)
+                        hit.add(d);
+                }
+            for (const d of hit) {
+                faults.push({ check: 'coords', message: `"${spot.name}" blocks the ${d} door of "${seedRoom.name}" -- keep the doorway and the cell in front of it clear.`, rooms: [seedRoom.name] });
+            }
+        }
+    }
+    return faults;
+}
+/**
+ * SPIDERS (utilities/spider.ts): the host they ride exists, and they can
+ * actually jack in -- the BUILT NPC is asked the boot's own question
+ * (spiderRefusal), so a missing deck or DNI reads here exactly as the
+ * engine would refuse it.
+ */
+export function authoredSpiderFaults(seed, built) {
+    const faults = [];
+    const rooms = new Map((seed.rooms ?? []).map(r => [r.name, r]));
+    for (const npc of seed.npcs ?? []) {
+        const p = npc.player;
+        if (!p.jackedInto)
+            continue;
+        const where = p.startLocation ? [p.startLocation] : [];
+        const host = rooms.get(p.jackedInto);
+        if (!host?.hasNode) {
+            faults.push({ check: 'matrix', message: `${p.name} is jacked into "${p.jackedInto}", which has no host.`, rooms: where });
+            continue;
+        }
+        const actor = built?.getActor(p.name);
+        if (actor instanceof NPC && actor.plane === 'meat') {
+            const why = spiderRefusal(actor, p.sim ?? 'cold');
+            if (why)
+                faults.push({ check: 'matrix', message: `${p.name} can't jack in: ${why}`, rooms: where });
+        }
+    }
+    return faults;
+}
+/**
+ * WARDS ARE A ROOM'S (user 2026-10-06; SR5 p.297-298, p.315-316): a
+ * warded room carries the ward's Force -- what pressing through and
+ * tearing at it are tested against -- and, if the author names one, the
+ * magician who raised it, who crosses it freely. A ward is never a
+ * device: that was the door-lock it used to be, and it stopped bodies
+ * that canon says walk through. Canon caps a ritual's Force nowhere in
+ * the ritual rules (p.296), so the audit asks only for a real Force.
+ */
+export function authoredWardFaults(seed, built) {
+    const faults = [];
+    const cast = new Set((seed.npcs ?? []).map(n => n.player.name));
+    for (const room of seed.rooms ?? []) {
+        for (const d of room.devices ?? []) {
+            if (d.kind === 'ward') {
+                faults.push({ check: 'security', message: `"${d.name}" in "${room.name}" is a ward device -- a ward is the room's, not a thing in it. Remove it and ward the room it protects.`, rooms: [room.name] });
+            }
+        }
+        if (!room.warded)
+            continue;
+        const force = room.wardForce;
+        if (force === undefined || !Number.isInteger(force) || force < 1) {
+            faults.push({ check: 'security', message: `The ward over "${room.name}" needs a Force (a whole number, 1 or more) -- pressing through it is Magic + Charisma against Force x 2.`, rooms: [room.name] });
+        }
+        if (room.wardCreator !== undefined) {
+            if (!cast.has(room.wardCreator)) {
+                faults.push({ check: 'security', message: `The ward over "${room.name}" names ${room.wardCreator} as its creator, who is not in the cast.`, rooms: [room.name] });
+            }
+            else {
+                const actor = built?.getActor(room.wardCreator);
+                if (actor instanceof NPC && !actor.isAwakened()) {
+                    faults.push({ check: 'security', message: `${room.wardCreator} can't have raised the ward over "${room.name}" -- a ward is a ritual, and they are mundane.`, rooms: [room.name] });
+                }
+            }
+        }
+    }
+    return faults;
+}
+/**
+ * THE GROUND AND THE SPACES ON IT (user rulings 2026-10-06): one ground,
+ * storey 0; outdoor spaces may overlap the ground but not each other on
+ * the same storey (rooms cut out of anything -- district-plane.ts
+ * roomAtCell ranks them).
+ */
+export function authoredGroundFaults(seed) {
+    const faults = [];
+    const rooms = seed.rooms ?? [];
+    const grounds = rooms.filter(r => r.ground);
+    if (grounds.length > 1)
+        faults.push({ check: 'plan', message: `There can be only one ground -- ${grounds.map(r => `"${r.name}"`).join(', ')} are all marked as it.`, rooms: grounds.map(r => r.name) });
+    for (const g of grounds) {
+        if (!g.outdoors || (g.storey ?? 0) !== 0)
+            faults.push({ check: 'plan', message: `The ground "${g.name}" must be outdoors, on storey 0.`, rooms: [g.name] });
+    }
+    const spaces = rooms.filter(r => r.outdoors && !r.ground && r.footprint);
+    for (let i = 0; i < spaces.length; i++) {
+        for (let j = i + 1; j < spaces.length; j++) {
+            const a = spaces[i];
+            const b = spaces[j];
+            if ((a.storey ?? 0) !== (b.storey ?? 0))
+                continue;
+            const fa = a.footprint;
+            const fb = b.footprint;
+            if (fa.x < fb.x + fb.w && fb.x < fa.x + fa.w && fa.y < fb.y + fb.h && fb.y < fa.y + fa.h) {
+                faults.push({ check: 'plan', message: `"${a.name}" and "${b.name}" overlap -- two outdoor spaces may only overlap the ground, or each other on different storeys.`, rooms: [a.name, b.name] });
+            }
+        }
+    }
+    return faults;
+}
+export async function validateAuthoredRun(seed) {
+    const { faults, built } = await SceneSeedGenerator.auditSeed(prepareAuthoredSeed(seed).seed);
+    return [...authoredGroundFaults(seed), ...authoredItemFaults(seed), ...authoredSpotFaults(seed), ...authoredNpcFaults(seed), ...authoredSecurityFaults(seed), ...authoredDoorwayFaults(seed, built), ...authoredDoorstepFaults(seed, built), ...authoredSpiderFaults(seed, built), ...authoredWardFaults(seed, built), ...faults.map(f => ({ ...f, rooms: roomsNamed(f.message, seed) }))];
+}
+export function matrixWire(built) {
+    const rooms = built.getRooms();
+    const physical = Object.values(rooms).filter(r => r.roomType !== 'host');
+    const hosts = physical.filter(r => r.host).map(r => {
+        const host = r.host;
+        return {
+            room: r.name,
+            label: host.displayName ?? `${r.name.replace(/^the\s+/i, '')} host`,
+            rating: host.rating,
+            ...(host.gridSeed ? { grid: host.gridSeed } : {}),
+            files: host.files().map(f => f.name),
+            ic: resolveICOrder(host.icOrder).map(t => t.name),
+            icAuthored: (host.icOrder?.length ?? 0) > 0,
+            ...(r.owner ? { owner: r.owner } : {}),
+            // Who is jacked in and riding it (utilities/spider.ts).
+            spiders: built.allActors ? spidersIn(built, host).map(n => n.name) : [],
+        };
+    });
+    const links = [];
+    for (const r of physical) {
+        for (const d of r.devices ?? []) {
+            links.push({ kind: 'device', name: d.name, room: r.name, host: deviceMaster(rooms, r, d)?.name, wireless: d.wireless, silent: d.silent });
+        }
+        if (isWatched(r) && r.ensureCameras().length > 0) {
+            const byHost = new Map();
+            for (const c of r.ensureCameras()) {
+                const host = lensMaster(rooms, r, c)?.name;
+                byHost.set(host, [...(byHost.get(host) ?? []), c.name]);
+            }
+            for (const [host, lenses] of byHost) {
+                const n = lenses.length;
+                links.push({
+                    kind: 'cameras', name: `${n} camera${n === 1 ? '' : 's'}`, room: r.name,
+                    host, wireless: r.ensureCameras().some(c => lenses.includes(c.name) && lensBroadcasts(rooms, r, c)), silent: false, lenses,
+                });
+            }
+        }
+    }
+    return { hosts, links };
+}
+export async function previewAuthoredRun(seed, heads = 1) {
+    const prepared = prepareAuthoredSeed(seed, heads);
+    const { faults, built } = await SceneSeedGenerator.auditSeed(prepared.seed);
+    const rooms = {};
+    for (const room of Object.values(built?.getRooms() ?? {})) {
+        const wire = roomGridWire(room);
+        if (wire)
+            rooms[room.name] = wire;
+    }
+    return {
+        faults: [...authoredGroundFaults(seed), ...authoredItemFaults(seed), ...authoredSpotFaults(seed), ...authoredNpcFaults(seed), ...authoredSecurityFaults(seed), ...authoredDoorwayFaults(seed, built), ...authoredDoorstepFaults(seed, built), ...authoredSpiderFaults(seed, built), ...authoredWardFaults(seed, built), ...faults.map(f => ({ ...f, rooms: roomsNamed(f.message, seed) }))],
+        rooms,
+        ...(built ? { matrix: matrixWire(built) } : {}),
+        payout: prepared.seed.winCondition?.payout,
+        securityTier: prepared.seed.securityTier,
+        notes: prepared.notes,
+    };
+}
+/** THE IC THE ENGINE RUNS, in its default launch order -- the editor's
+ *  lineup picker (an author may order any subset; Data Trails p.91-102). */
+export function icVocabulary() {
+    return IC_TYPES.map(t => t.name);
+}
+/** THE GRIDS A HOST CAN SIT ON (SR5 p.233-234): the public grid, the
+ *  district's local grid, or one of the Big Ten's global grids -- the
+ *  room seed's hostGrid values, as game.ts resolves them. */
+export function gridVocabulary() {
+    return ['public', 'local', ...BIG_TEN.map(c => `global:${c}`)];
+}
+//# sourceMappingURL=authored-run.js.map