@maka/maka-cli 5.378.0 → 5.379.1

package/bundle/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.378.0",
+  "version": "5.379.1",
   "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/call.js

@@ -19,6 +19,7 @@ import { inLiveCombat } from '../utilities/action-cost.js';
 import { radioIsDark } from '../utilities/pan-devices.js';
 import { NPC } from '../models/npc.js';
 import { METERS_PER_LEVEL } from '../utilities/room-grid.js';
+import { heldByName, releaseHeld, receiveData } from '../utilities/data-library.js';
 export class CallCommand extends Command {
     static verb = 'call';
     static description = 'Call someone remotely over a commlink (no need to be in the same room, or the same district; commlink must be equipped).';
@@ -612,9 +613,21 @@ export class CallCommand extends Command {
         let deliveredItemName = '';
         const wc = this.scene.getWinCondition();
         if (wc?.type === 'give' && wc.item && wc.toNpc?.toLowerCase() === target.name.toLowerCase()) {
-            const item = this.actor.inventory.getItem(wc.item);
-            if (item) {
-                const delivered = this.actor.inventory.transferItemTo(item.name, target.inventory);
+            // A chip in the pack OR a file on a device (digital inventory,
+            // 2026-10-04): over a call the data is simply SENT, which is what a
+            // device library is for -- the chip was never required.
+            const held = heldByName(this.actor, wc.item);
+            const item = held?.file;
+            if (held && item) {
+                let delivered;
+                if (held.device) {
+                    delivered = item.transferable !== false && releaseHeld(this.actor, held);
+                    if (delivered)
+                        receiveData(target, item);
+                }
+                else {
+                    delivered = this.actor.inventory.transferItemTo(item.name, target.inventory);
+                }
                 if (delivered) {
                     this.scene.updateInventory(this.scene.getPlayer().inventory);
                     this.scene.checkWinCondition(item.name, target.name);

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

@@ -1,178 +1,318 @@
 import { Command } from './command.js';
 import { billAction } from '../utilities/action-cost.js';
-import { roomsInReach, gridVicinity } from '../utilities/grid-reach.js';
+import { roomsInReach, gridVicinity, hostDoorOpenFor } from '../utilities/grid-reach.js';
+import { whereIsThat } from '../utilities/matrix-roster.js';
 import { hint } from '../utilities/hints.js';
-import { Category } from '../types/shared/item-enum.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { fileReach, planeTintItemName } from '../utilities/planes.js';
+import { hostLabel } from '../utilities/grid-names.js';
+import { editFileBlocked, rollEditFile } from '../utilities/edit-file-test.js';
+import { copyFile, deviceHas, fileOnto, findDataDevice, libraryDevice } from '../utilities/data-library.js';
+import { NPC } from '../models/npc.js';
 /**
- * "download" -- WRITE A FILE OUT OF THE GRID AND ONTO SOMETHING YOU CAN
- * HAND OVER.
+ * "download" -- COPY A FILE OFF THE GRID INTO YOUR DEVICE'S LIBRARY.
  *
- * Two reports, one hole:
+ * DIGITAL INVENTORY (user ruling 2026-10-04) replaces the chip. A file
+ * used to come down as a Datachip in the pack (the 2026-08-30 ruling);
+ * now it is written to the library of the device carrying your persona
+ * (utilities/data-library.ts), and it is a COPY -- Edit File, p.239:
+ * "create, change, COPY, delete ... If you use this action to copy a
+ * file, you are the new file's owner." The host keeps its original, so a
+ * job that wants the file GONE is still "erase".
  *
- *   aNeh5TELvdgeS2vpg (Deditri): "paydata in this run is stuck with the
- *   sprite, It won't give it to me and there is not way to get it to
- *   Marrow."
+ * WHERE FROM. Files inside the host you stand in; files loose on the grid
+ * where you are; dim icons out in the district (pp.217-218); and files
+ * your own compiled sprites are holding -- the one source nothing else
+ * could reach (aNeh5TELvdgeS2vpg, MxiKYFGeStiyvibJN). A sprite's file is
+ * already yours, so it MOVES to your device rather than copying.
  *
- *   MxiKYFGeStiyvibJN (Maka): "there needs to be a way to move data from
- *   matrix to meatworld in the form of 'download'."
+ * THE TEST (p.239): Computer + Logic [Data Processing] v. the host,
+ * Marks Required 1 -- the same roll erase makes (utilities/edit-file-test.ts).
+ * Two arms stay free of dice, both deliberate:
+ *   - a CRACKED host (three marks, hack.ts): its architecture treats you
+ *     as staff, and its own files open with it -- the line hack.ts draws;
+ *   - a file not on any host (loose on the grid, or your sprite's): the
+ *     defender would be the file's owner, and an unowned or self-owned
+ *     file has nobody to roll. Canon names no defender here; none is
+ *     invented.
+ * Before 2026-10-04 this verb never rolled and never asked for a crack,
+ * so it read an uncracked host's archive that `take` refused -- the two
+ * now share one path (take routes matrix-plane pickups here).
  *
- * THE CONVERSION ALREADY EXISTED AND HAD NO NAME. take.ts has flipped a
- * matrix-plane file to `meat` and re-categorised it as a Datachip for a
- * while now -- "pulled down ... written to a chip". So the mechanic was
- * built; what was missing was a VERB anybody would think to type, and a
- * source other than the floor.
+ * THE TIME: a Complex Action (p.239) wherever an action economy exists.
  *
- * THE SPRITE IS THE CASE THAT HAD NO ROUTE AT ALL. `take` reads the
- * ROOM's inventory, and Deditri's chip was in a compiled sprite's hands.
- * `give` was no help from either end: it refuses whenever an actor is off
- * the meat plane, and a sprite is `plane: 'matrix'` by construction, so
- * "order sprite give me the chip" could never work. The only route left
- * was `decompile` -- destroying your own sprite to make it drop the
- * loot -- which is exactly the "hidden, non-obvious solution" the vetting
- * described. It is also a lousy trade the player has no way to know they
- * are making.
- *
- * SO THIS VERB READS BOTH SOURCES: files loose on the grid where you are
- * standing, and files carried by YOUR OWN compiled sprites. Somebody
- * else's sprite is not a shelf you may take from -- that is a hack, and
- * hack.ts owns it.
- *
- * DELIBERATELY NOT A TEST -- BUT IT IS AN ACTION. Pulling a file you
- * already have reach on is not an opposed action in this engine --
- * `take` does not roll for it either, and getting past whatever GUARDED
- * the file is what the host crack and the mark already charged for.
- * Adding dice here would price the same obstacle twice.
- *
- * The TIME is a separate bill, and it was going unpaid: copying a file
- * is Edit File, a COMPLEX ACTION (p.239). See the billAction call in
- * execute() for what that was costing in a fight.
+ * "download <file> to <device>" picks the library; without it the file
+ * lands on the persona's device. A runner with no data device at all is
+ * refused (p.250-251: a living persona has no storage) -- see pull().
  */
 export class DownloadCommand extends Command {
     static verb = 'download';
-    static description = 'Write a file out of the Matrix onto a chip you carry -- "download <file>". Reads data loose on the grid where you stand AND data your own sprites are holding, which is the one place nothing else could reach it. A downloaded file is ordinary meat-world cargo: you can carry it, stash it, or hand it to somebody.';
+    static description = 'Copy a file off the Matrix into your device\'s library -- "download <file>" (or "download <file> to <device>"). Edit File (SR5 p.239, a Complex Action): Computer + Logic [Data Processing] v. the host, with a mark on it -- no roll once the host is cracked, or for data loose on the grid or held by your own sprites. The host keeps its original. "inv" lists your libraries; "transfer" moves files between devices or onto a chip.';
     async execute(args = []) {
+        const actor = this.actor;
+        let words = args.join(' ').trim();
+        // "... to <device>": split on the LAST " to ", and only when the tail
+        // names a data device you carry -- a file called "Letter to Krow"
+        // still downloads whole.
+        let target;
+        const toMatch = words.match(/^(.*)\s+(?:to|onto|into)\s+(.+)$/i);
+        if (toMatch) {
+            const device = findDataDevice(actor, toMatch[2]);
+            if (device) {
+                target = device;
+                words = toMatch[1].trim();
+            }
+        }
+        const { pullable, reach } = this.inReach();
+        if (pullable.length === 0 && reach === 'connect') {
+            const room = gridVicinity(actor);
+            return `Those files are on the ${room.offlineServer} -- off the network entirely. No persona reaches that box; your BODY has to be in ${room.name} and cabled in (p.233).`;
+        }
+        if (pullable.length === 0 && !words) {
+            return `Nothing to pull down -- no data on the grid here, and nothing your sprites are carrying.${reach === 'enter' ? hint(` (This room's files live INSIDE its host -- "enter" first.)`) : ''}`;
+        }
+        // Bare "download" is the LIST. A verb whose whole reason for existing
+        // is that nobody could find the file should say what it can see.
+        if (words.length === 0) {
+            const lines = [`{light-blue-fg}Within reach to pull down:{/light-blue-fg}`];
+            for (const p of pullable) {
+                const where = p.kind === 'host' ? `in ${hostLabel(p.host.over)}'s archive`
+                    : p.kind === 'sprite' ? `held by ${p.npc.name}`
+                        : p.kind === 'far' ? `a dim icon out on the grid (noise -${p.noise})`
+                            : 'loose on the grid here';
+                lines.push(`  ${planeTintItemName(p.item, actor.plane)} -- ${where}`);
+            }
+            const home = libraryDevice(actor);
+            lines.push(hint(home ? `("download <file>" copies it onto your ${home.name}.)` : `(You carry no device to copy onto -- a living persona has no storage, p.250-251.)`));
+            return lines.join('\n');
+        }
+        const picked = fuzzyPickName(words, pullable.map(p => p.item.name));
+        const source = picked ? pullable.find(p => p.item.name === picked) : undefined;
+        if (!source) {
+            // IN THE ARCHIVE, NOT YET FOUND: the host holds it, but nothing has
+            // turned the archive up for this persona (search, or a crack).
+            // OUT ON THE GRID, OUTSIDE THE HOST THAT HOLDS IT (p.246): the shell
+            // is all a persona reads from out here.
+            const here = actor.plane === 'matrix' ? gridVicinity(actor) : actor.currentLocation;
+            if (reach === 'enter' && here.host && fuzzyPickName(words, here.host.files().map(f => f.name))) {
+                return `That file is INSIDE the host -- you're on the outside grid, reading its shell (p.246). ${hostDoorOpenFor(here, actor) ? `"enter" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
+            }
+            const inside = actor.plane === 'matrix' ? actor.hostInside : undefined;
+            if (inside && fuzzyPickName(words, inside.files().map(f => f.name))) {
+                return `You haven't found ${hostLabel(inside.over)}'s archive yet -- there is nothing on your display to copy. ${hint(`"search" runs a Matrix Search inside the host (p.241); a crack ("hack") opens it outright.`)}`;
+            }
+            const elsewhere = this.whereElse(words);
+            if (elsewhere)
+                return elsewhere;
+            return `No file called "${words}" within reach.${hint(` ("download" on its own lists what is.)`)}`;
+        }
+        const out = this.pull(source, target);
+        return out.text;
+    }
+    /**
+     * A FILE ELSEWHERE IN THE DISTRICT (matrix model): named from the grid,
+     * the answer is where it is and what stands in the way -- the offline
+     * server that needs your body, the host that needs a mark. Moved here
+     * from take.ts with the rest of the matrix pickup.
+     */
+    whereElse(query) {
+        const actor = this.actor;
+        if (actor.plane !== 'matrix' || actor.insideHost)
+            return undefined;
+        const room = gridVicinity(actor);
+        const far = whereIsThat(this.rooms ?? this.scene.getRooms(), actor, query);
+        if (!far || far.room === room || !(far.reach === 'open' || far.remembered))
+            return undefined;
+        if (far.reach === 'offline')
+            return `${far.item.name} is on the ${far.room.offlineServer} in ${far.room.name} -- an offline server, off the network entirely. No persona reaches that box; your BODY has to be in ${far.room.name} (p.233).`;
+        if (far.reach === 'host')
+            return `${far.item.name} is INSIDE ${far.room.name}'s host, and you're out on the grid looking at its shell (p.246). ${hostDoorOpenFor(far.room, actor) ? `"enter ${far.room.name}" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
+        return undefined;
+    }
+    /**
+     * Every file this persona can pull from where it stands, with the
+     * reason the room's own files are or are not in reach.
+     */
+    inReach() {
         const actor = this.actor;
         // WHERE THE PERSONA STANDS (matrix model 2026-09-02): inside a host, the host's room; on the grid, the body's.
         const room = actor.plane === 'matrix' ? gridVicinity(actor) : actor.currentLocation;
-        // WHAT IS IN REACH, from both sources.
-        //
-        // The room's own files honour fileReach (utilities/planes.ts) -- a
-        // host's contents are inside the host and an offline server wants a
-        // body in the room -- because a download that ignored the boundary
-        // would be a way to read a sealed host from the street, which is the
-        // very thing eJANPpm7qCaCAJBJw was filed about.
         const reach = fileReach(actor, room);
-        const loose = reach === 'open'
-            ? room.inventory.getAllItems().filter(i => i.plane === 'matrix')
-            : [];
+        const pullable = [];
+        // The room's own files honour fileReach (utilities/planes.ts): a host's
+        // contents are inside the host, and an offline server wants a body.
+        if (reach === 'open') {
+            const host = actor.hostInside && actor.hostInside.over === room && !room.offlineServer ? actor.hostInside : undefined;
+            if (host) {
+                // YOU CANNOT COPY WHAT YOU HAVE NOT SEEN (edit-file.ts's rule):
+                // the archive is listed once a Matrix Search turned it up, or the
+                // host is cracked.
+                if (host.searchedBy.has(actor.name) || host.cracked) {
+                    for (const item of host.files())
+                        pullable.push({ item, kind: 'host', room, host });
+                }
+            }
+            else {
+                for (const item of room.inventory.getAllItems()) {
+                    if (item.plane === 'matrix')
+                        pullable.push({ item, kind: 'loose', room });
+                }
+            }
+        }
         // FARTHER OUT (SR5 pp.217-218): data loose on the grid elsewhere in the
         // district is a dim icon in reach -- open where no host guards it.
-        const far = [];
         if (actor.plane === 'matrix' && !actor.insideHost) {
             for (const { room: r, noise } of roomsInReach(this.rooms ?? this.scene.getRooms(), actor).slice(1)) {
-                if (fileReach(actor, r) !== 'open')
+                if (fileReach(actor, r) !== 'open' || r.hasNode)
                     continue;
                 for (const item of r.inventory.getAllItems())
                     if (item.plane === 'matrix')
-                        far.push({ item, room: r, noise });
+                        pullable.push({ item, kind: 'far', room: r, noise });
             }
         }
         // YOUR sprites, not everyone's. `compiledBy` is not modelled on the
-        // shell, so ownership is "it is in YOUR companion list" -- which is
-        // the same thing the order/decompile verbs already mean by it.
-        const mine = (this.game?.companions ?? []).filter(c => c.kind === 'sprite');
-        const carried = [];
-        for (const entry of mine) {
+        // shell, so ownership is "it is in YOUR companion list" -- the same
+        // thing the order/decompile verbs already mean by it.
+        for (const entry of (this.game?.companions ?? []).filter(c => c.kind === 'sprite')) {
             for (const item of entry.npc.inventory.getAllItems()) {
                 if (item.plane === 'matrix')
-                    carried.push({ npc: entry.npc, item });
+                    pullable.push({ item, kind: 'sprite', npc: entry.npc });
             }
         }
-        if (loose.length === 0 && carried.length === 0 && far.length === 0) {
-            return `Nothing to pull down -- no data on the grid here, and nothing your sprites are carrying.${reach === 'enter' ? hint(` (This room's files live INSIDE its host -- "enter" first.)`) : ''}`;
+        return { pullable, reach };
+    }
+    /**
+     * Pulls one file: the gates, the bill, the roll, the copy. `ok` is true
+     * only when a file actually landed -- take-all stops on a refusal that
+     * is about the ACTOR (out of actions), not the file.
+     */
+    pull(source, target) {
+        const actor = this.actor;
+        const item = source.item;
+        // A LOOSE END IS ERASED, NOT DOWNLOADED: the desk keeps its copy
+        // whatever comes down to yours (win-condition-seed.ts 'erase').
+        const wc = this.scene.getWinCondition?.();
+        if (wc?.type === 'erase' && wc.item?.toLowerCase() === item.name.toLowerCase()) {
+            return { ok: false, text: `Copying ${item.name} changes nothing -- the desk keeps its own. ${hint(`"erase ${item.name}" is what makes it go away (Edit File, p.239).`)}` };
         }
-        // Bare "download" is the LIST. A verb whose whole reason for existing
-        // is that nobody could find the file should say what it can see.
-        const query = args.join(' ').trim();
-        if (query.length === 0) {
-            const lines = [`{light-blue-fg}Within reach to pull down:{/light-blue-fg}`];
-            for (const i of loose)
-                lines.push(`  ${planeTintItemName(i, actor.plane)} -- loose on the grid here`);
-            for (const c of carried)
-                lines.push(`  ${planeTintItemName(c.item, actor.plane)} -- held by ${c.npc.name}`);
-            for (const f of far)
-                lines.push(`  ${planeTintItemName(f.item, actor.plane)} -- a dim icon out on the grid (noise -${f.noise})`);
-            lines.push(hint(`("download <file>" writes it to a chip you carry.)`));
-            return lines.join('\n');
+        // PROTECTED FILES (p.239: "if the file you want to copy has protection
+        // on it, this action automatically fails"). The one protection the
+        // engine models is a sprite's Hash (p.257) -- your own sprite's file
+        // is yours to move.
+        if (item.hashedBy && source.kind !== 'sprite') {
+            return { ok: false, text: `${item.name} is wrapped in a Resonance algorithm -- a protected file, and Edit File fails on one outright (p.239). ${hint(`(Only ${item.hashedBy} unseals it.)`)}` };
         }
-        const names = [...loose.map(i => i.name), ...carried.map(c => c.item.name), ...far.map(f => f.item.name)];
-        const picked = fuzzyPickName(query, names);
-        if (!picked) {
-            return `No file called "${query}" within reach.${hint(` ("download" on its own lists what is.)`)}`;
+        const device = target ?? libraryDevice(actor);
+        if (device && deviceHas(device, item.name)) {
+            return { ok: false, text: `Your ${device.name} already holds ${item.name}.` };
         }
-        const fromSprite = carried.find(c => c.item.name === picked);
-        const fromFar = !fromSprite && !loose.some(i => i.name === picked) ? far.find(f => f.item.name === picked) : undefined;
-        const item = fromSprite ? fromSprite.item : fromFar ? fromFar.item : loose.find(i => i.name === picked);
-        // A LOOSE END IS ERASED, NOT DOWNLOADED (take.ts has the same gate):
-        // the desk keeps its copy whatever comes down to your chip.
-        const wc = this.scene.getWinCondition?.();
-        if (wc?.type === 'erase' && wc.item?.toLowerCase() === item.name.toLowerCase()) {
-            return `Pulling ${item.name} down changes nothing -- the desk keeps its own. ${hint(`"erase ${item.name}" is what makes it go away (Edit File, p.239).`)}`;
-        }
-        // COPYING A FILE IS EDIT FILE, AND EDIT FILE IS A COMPLEX ACTION
-        // (p.239: "Edit File allows you to create, change, COPY, delete, or
-        // protect any kind of file"). The no-dice ruling above stands -- the
-        // host crack already charged for the obstacle -- but "not a test"
-        // was silently read as "not an action", and in a Combat Turn that is
-        // a different claim entirely. Found in jfjjTmJ7NYwDaFiyB's own
-        // bench: walking into a rating-3 host wakes Patrol IC, `search` is
-        // correctly refused ("a Matrix Search takes minutes ... a Combat
-        // Turn is three seconds") and `download` then emptied the archive
-        // for FREE with the ice mid-turn on the runner. That makes the fight
-        // the report asked for optional -- stroll in, take the paydata, and
-        // the ice never mattered.
+        // NO STORAGE, NO COPY (SR5 p.250-251, RAG-checked 2026-10-04): "your
+        // living persona is just a persona, not a device, you don't have any
+        // on-board storage; ... you can store files in nearby devices." A
+        // persona with no device to write to has nowhere for the copy to go
+        // -- and a datachip in the pack has no wireless for a mind on the grid
+        // to write through. In practice this is the technomancer with no
+        // commlink: every other runner needed a device to jack in at all.
+        // Before 1.191.1 this fell back to a chip, which canon never allowed.
         //
-        // billAction is a no-op outside an encounter, so the quiet case --
-        // an empty host, a file loose on the grid -- is untouched: still one
-        // verb, no roll, no friction. It bills only where an action economy
-        // exists to bill against, and a refusal returns BEFORE the item
-        // moves, so a runner out of actions keeps both the file and the turn.
+        // An NPC persona (a sprite, an agent) carries what it takes in its own
+        // hands -- the shelf download.ts already reads from a sprite.
+        const npcHands = !device && actor instanceof NPC;
+        if (!device && !npcHands) {
+            return {
+                ok: false,
+                text: actor.isTechnomancer()
+                    ? `Your living persona is a persona, not a device -- it has no storage to copy ${item.name} into (p.250-251). ${hint(`Carry a commlink, deck or RCC and the copy lands there; reading files is not riding the hardware, so your Resonance stays yours.`)}`
+                    : `You carry no commlink, deck or RCC to copy ${item.name} onto.`,
+            };
+        }
+        // THE HOST'S GATE: cracked opens it (hack.ts); otherwise Edit File
+        // wants a mark (p.239) before it can be tried at all.
+        const host = source.kind === 'host' ? source.host : undefined;
+        const needsRoll = !!host && !host.cracked;
+        if (host && needsRoll && (host.marksBy.get(actor.name) ?? 0) < 1) {
+            return { ok: false, text: `Edit File needs a MARK (p.239) -- you hold none on ${hostLabel(host.over)}. ${hint(`"hack" the host for one.`)}` };
+        }
+        if (needsRoll) {
+            const burned = editFileBlocked(actor);
+            if (burned)
+                return { ok: false, text: burned, stop: true };
+        }
+        // COPYING A FILE IS EDIT FILE, A COMPLEX ACTION (p.239). billAction
+        // is a no-op outside an encounter; a refusal returns BEFORE anything
+        // moves, so a runner out of actions keeps the turn (jfjjTmJ7NYwDaFiyB:
+        // an archive emptied for free with ice mid-turn).
         const bill = billAction(this.scene, actor, 'complex', 'Edit File (copy)');
         if (bill)
-            return bill;
-        // THE CONVERSION, identical to take.ts's. Same two fields, because a
-        // file that came down by one verb and a file that came down by the
-        // other must be the same object afterwards -- a chip you can `give`.
-        try {
-            actor.addInventory(item);
+            return { ok: false, text: bill, stop: true };
+        if (host && needsRoll) {
+            const roll = rollEditFile(this.scene, this.logger, actor, host, 'copy');
+            if (!roll.success) {
+                actor.performAction('edits a file', `${item.name} in ${hostLabel(host.over)}`, { quiet: this.scene.isHumanControlled(actor) });
+                this.logger.write(`${actor.name} failed to copy "${item.name}" from ${host.over.name}: ${roll.hits} v ${roll.defence}.`);
+                return { ok: false, text: `The copy stalls -- ${hostLabel(host.over)}'s checksum rejects the read and nothing comes down. A failed edit is not a failed sleaze; nobody upstairs noticed.${hint(` (Try again; each attempt is a Complex Action.)`)}` };
+            }
+        }
+        // THE MOVE. A sprite's file is already yours and moves; everything
+        // else is a copy you now own (p.239), the original left in place.
+        let landed;
+        if (source.kind === 'sprite') {
+            source.npc.inventory.removeItem(item.name);
+            landed = item;
         }
-        catch {
-            return `You can't carry any more -- ${item.name} stays where it is.`;
+        else {
+            landed = copyFile(item, actor.name);
+            // Copying a file off the floor of the grid leaves the icon where it
+            // was, but you have now SEEN it -- nothing about plainSight changes.
         }
-        if (fromSprite) {
-            fromSprite.npc.inventory.removeItem(item.name);
+        let onto;
+        if (device) {
+            fileOnto(device, landed);
+            actor.noteConditionChanged();
+            onto = device;
         }
         else {
-            const source = fromFar ? fromFar.room : room;
-            source.inventory.removeItem(item.name);
-            source.plainSightItems.delete(item.name.toLowerCase());
-        }
-        item.plane = 'meat';
-        item.category = Category.Datachip;
-        actor.performAction('pulls a file down', `${item.name} writing to a chip`);
-        this.logger.write(`${actor.name} downloaded "${item.name}"${fromSprite ? ` from ${fromSprite.npc.name}` : ` from ${room.name}`}.`);
+            // An NPC persona's own hands (the refusal above covers everyone else).
+            landed.plane = 'matrix';
+            landed.atSpot = undefined;
+            actor.inventory.addItem(landed);
+        }
+        actor.performAction('copies a file', `${item.name}${onto ? ` onto ${onto.name}` : ''}`, { quiet: this.scene.isHumanControlled(actor) });
+        this.logger.write(`${actor.name} downloaded "${item.name}" (${source.kind}) ${onto ? `onto ${onto.name}` : 'into its own hands'}.`);
+        this.game?.requestSave('data');
         this.scene.updateStatus();
-        return fromSprite
-            ? [
-                `{light-blue-fg}${fromSprite.npc.name} opens its hands and the data pours out of them.{/light-blue-fg}`,
-                `You pull {bold}{underline}${item.name}{/underline}{/bold} down onto a chip -- meat-world cargo now.${hint(` (You can "give ${item.name}" to somebody standing in front of you.)`)}`,
-            ].join('\n')
-            : [
-                `{light-blue-fg}You pull {bold}{underline}${item.name}{/underline}{/bold} down off the grid -- written to a chip.{/light-blue-fg}`,
-                hint(`(Meat-world cargo now: carry it, stash it, or "give" it to somebody.)`),
-            ].join('\n');
+        const text = onto
+            ? source.kind === 'sprite'
+                ? `{light-blue-fg}${source.npc.name} opens its hands and the data pours out of them -- {bold}{underline}${item.name}{/underline}{/bold} is on your ${onto.name} now.{/light-blue-fg}`
+                : `{light-blue-fg}You copy {bold}{underline}${item.name}{/underline}{/bold} onto your ${onto.name}${host ? ` -- ${hostLabel(host.over)} keeps its original` : ''}.{/light-blue-fg}${hint(` ("give" or "call" hands it over straight from the device; "transfer ${item.name} to chip" writes it to physical media.)`)}`
+            : `{light-blue-fg}You take hold of ${item.name}.{/light-blue-fg}`;
+        // 'possess' objectives complete in the runner's hands; a device library
+        // is the runner's hands for data (scene.ts checkWinCondition).
+        if (this.scene.isHumanControlled(actor))
+            this.logger.log(text, { actor: actor.name });
+        if (!this.scene.isWinConditionTarget?.(actor.name)) {
+            this.scene.checkWinCondition?.(item.name, actor.name);
+        }
+        return { ok: true, text: this.scene.isHumanControlled(actor) ? '' : text };
+    }
+    /** "take all" on the Matrix plane: every file in reach here, one Edit File each. */
+    pullAll() {
+        const { pullable, reach } = this.inReach();
+        const here = pullable.filter(p => p.kind === 'host' || p.kind === 'loose');
+        if (here.length === 0) {
+            return reach === 'enter'
+                ? `Those files are INSIDE the host, and you're out on the grid looking at its shell (p.246). "enter" first.`
+                : `Nothing here to copy${this.actor.hostInside && !this.actor.hostInside.cracked && !this.actor.hostInside.searchedBy.has(this.actor.name) ? ` that you have found -- "search" runs a Matrix Search (p.241)` : ''}.`;
+        }
+        const lines = [];
+        for (const p of here) {
+            const r = this.pull(p);
+            if (r.text)
+                lines.push(r.text);
+            if (r.stop)
+                break;
+        }
+        return lines.join('\n');
     }
 }
 //# sourceMappingURL=download.js.map

package/bundle/typescript/src/commands/game/sideQuest/commands/edit-file.js

@@ -1,12 +1,9 @@
 import { Command } from './command.js';
-import { gridActionModifier } from '../utilities/grids.js';
 import { hint } from '../utilities/hints.js';
-import { rollPool, formatRoll } from '../utilities/dice.js';
 import { billAction } from '../utilities/action-cost.js';
-import { hostDefensePool } from '../utilities/matrix-intrusion.js';
+import { editFileBlocked, rollEditFile } from '../utilities/edit-file-test.js';
 import { hostLabel } from '../utilities/grid-names.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
-import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-audience.js';
 /**
  * EDIT FILE (SR5 p.239, RAG-checked 2026-09-14): a Complex Action, Marks
  * Required 1, Computer + Logic [Data Processing] v. Intuition + Firewall.
@@ -21,9 +18,10 @@ import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-aud
  *
  * WHAT SHIPS (loose ends, 2026-09-14): DELETE. The cleanup's objective
  * is a file the site keeps -- camera footage with the runner's face --
- * and copying it (the engine's `take` / `download`, which already
- * converts a matrix file to a chip) changes nothing about what the desk
- * still holds. Create, change and protect are named here as not built;
+ * and copying it changes nothing about what the desk still holds. COPY
+ * and CREATE shipped 2026-10-04 as "download" and "upload" (digital
+ * inventory), on the same roll (utilities/edit-file-test.ts); this verb
+ * routes "edit copy" / "edit create" to them. Change and protect are not built;
  * Crack File and the Data Bomb family wait on a per-file protection
  * rating (models/item.ts) and are their own item.
  *
@@ -64,9 +62,21 @@ export class EditFileCommand extends Command {
             }).execute(args);
         }
         const { op, word, rest } = this.operation(args);
+        // COPY and CREATE are built, under the verbs a player reaches for
+        // (digital inventory, 2026-10-04): copy is "download" (host to your
+        // device), create is "upload" (your device to the host). Same roll.
+        if (word === 'copy' || word === 'create') {
+            const ctx = { actor: this.actor, scene: this.scene, rooms: this.rooms, screen: this.screen, game: this.game };
+            if (word === 'copy') {
+                const { DownloadCommand } = await import('./download.js');
+                return new DownloadCommand(ctx).execute(rest);
+            }
+            const { UploadCommand } = await import('./upload.js');
+            return new UploadCommand(ctx).execute(rest);
+        }
         if (op !== 'delete') {
             const named = word ? `"${word}"` : 'that';
-            return `Edit File (p.239) can create, change, copy, delete or protect a file -- and this engine builds DELETE: "edit delete <file>" (or "erase <file>"). ${word === 'copy' ? 'Copying is "take" or "download" -- the file comes down to a chip.' : `${named} isn't built yet.`}`;
+            return `Edit File (p.239) can create, change, copy, delete or protect a file -- and this engine builds DELETE ("erase <file>"), COPY ("download <file>") and CREATE ("upload <file>"). ${named} isn't built yet.`;
         }
         if (actor.plane !== 'matrix') {
             return `Files are edited by a persona. ${hint(`"jack in" first.`)}`;
@@ -103,37 +113,22 @@ export class EditFileCommand extends Command {
             return `Edit File needs a MARK (p.239) -- you hold none on ${hostLabel(room)}. ${hint(`"hack" the host for one.`)}`;
         }
         // Binder IC eats Data Processing; a bracket of 0 permits no hits.
-        const burned = actor.burnedAttributeRefusal('dataProcessing');
+        const burned = editFileBlocked(actor);
         if (burned)
             return burned;
         const bill = billAction(this.scene, actor, 'complex', 'Edit File');
         if (bill)
             return bill;
-        const computer = actor.skillRating('computer');
-        // Inside a host no grid penalty applies (p.246); silence still taxes
-        // every Matrix action (p.235-236, Player.matrixActionPenalty).
-        // The grid tax was NAMED here and never charged -- gridActionModifier
-        // is the helper that answers both halves, returning 0 inside a host
-        // and the public grid's -2 out on it (p.233).
-        const grid = gridActionModifier(actor.currentGrid, !!actor.hostInside, actor.currentGrid);
-        const pool = Math.max(1, actor.logic + (computer > 0 ? computer : -1)
-            + actor.matrixActionPenalty + grid.total + actor.woundModifier - actor.sustainingPenalty);
-        const limit = actor.matrixAttribute('dataProcessing');
-        const defence = hostDefensePool(host);
-        const attempt = rollPool(pool, limit, { gremlins: actor.deckGremlins });
-        const resist = rollPool(defence.pool);
-        if (showsMechanics(this.scene, actor)) {
-            this.logger.meta(`${mechanicsActorPrefix(this.scene, actor)}Edit File (delete) -- Computer + Logic [Data Processing]: ${formatRoll(attempt)}`);
-            this.logger.meta(`  v. ${hostLabel(room)} (${defence.label}, rating standing in for Intuition): ${formatRoll(resist)}`);
-        }
+        // The roll is utilities/edit-file-test.ts, shared with download (copy)
+        // and upload (create) so the family cannot drift apart.
+        const attempt = rollEditFile(this.scene, this.logger, actor, host, 'delete');
         actor.performAction('edits a file', `${file.name} in ${hostLabel(room)}`, { quiet: this.scene.isHumanControlled(actor) });
-        if (attempt.hits <= resist.hits) {
-            this.logger.write(`${actor.name} failed to delete "${file.name}" in ${room.name}: ${attempt.hits} v ${resist.hits}.`);
+        if (!attempt.success) {
+            this.logger.write(`${actor.name} failed to delete "${file.name}" in ${room.name}: ${attempt.hits} v ${attempt.defence}.`);
             return `The file's checksum holds -- your edit rolls off it and the archive keeps ${file.name}. Nothing upstairs noticed: a failed edit is not a failed sleaze.${hint(` (Try again; each attempt is a Complex Action.)`)}`;
         }
-        room.inventory.removeItem(file.name);
-        room.plainSightItems.delete(file.name.toLowerCase());
-        this.logger.write(`${actor.name} deleted "${file.name}" from ${room.name}'s host: ${attempt.hits} v ${resist.hits}.`);
+        host.removeFile(file.name);
+        this.logger.write(`${actor.name} deleted "${file.name}" from ${room.name}'s host: ${attempt.hits} v ${attempt.defence}.`);
         this.scene.addWorldEvent(`${file.name} was erased from ${host.name}'s archive.`, { plane: 'matrix' });
         const banner = this.scene.checkErased?.(file.name, actor.name);
         this.scene.updateStatus();