@maka/maka-cli 5.378.0 → 5.379.1

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

@@ -2,6 +2,7 @@ import { Command } from './command.js';
 import { priceOf, merchantOf, findWare, mintWare, takeRecentSale } from '../utilities/commerce.js';
 import { sameSpot, spotOf, spotRefusal } from '../utilities/spots.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { findDeviceFile, releaseHeld, receiveData } from '../utilities/data-library.js';
 export class GiveCommand extends Command {
     static verb = 'give';
     /** Touches another actor: authorized per-act for AI-driven actors
@@ -75,6 +76,18 @@ export class GiveCommand extends Command {
         }
         // === Try to give an item ===
         let item = this.actor.inventory.getItem(itemOrAmount);
+        // DATA ON A DEVICE IS IN YOUR HANDS TOO (digital inventory, user ruling
+        // 2026-10-04): a file in your commlink's library is beamed across the
+        // table, no chip required. Pack first -- a chip by that name wins --
+        // then the device libraries.
+        let fromDevice;
+        if (!item) {
+            const held = findDeviceFile(this.actor, itemOrAmount);
+            if (held) {
+                item = held.file;
+                fromDevice = held;
+            }
+        }
         // SERVING SHOP STOCK: a vendor's wares live in the ROOM (owner-tagged),
         // not in their pockets -- so "give bowl of laksa to Maka" from Mama Wu
         // used to fail silently while she stood next to her own wok. A real
@@ -203,7 +216,17 @@ export class GiveCommand extends Command {
             this.scene.checkWinCondition(item.name, recipient.name);
             return `You hand over the ${item.name}.${tillNote}`;
         }
-        const didTransfer = this.actor.inventory.transferItemTo(item.name, recipient.inventory);
+        // A device file MOVES to the recipient -- onto their own device when
+        // they carry one (data-library receiveData), else a chip in hand.
+        let didTransfer;
+        if (fromDevice) {
+            didTransfer = item.transferable !== false && releaseHeld(this.actor, fromDevice);
+            if (didTransfer)
+                receiveData(recipient, item);
+        }
+        else {
+            didTransfer = this.actor.inventory.transferItemTo(item.name, recipient.inventory);
+        }
         if (!didTransfer) {
             this.logger.write(`Item "${item.name}" is not transferable.`);
             this.actor.performAction('did not give', `item cannot be given`);

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

@@ -2,6 +2,7 @@ import { Command } from './command.js';
 import { hint } from '../utilities/hints.js';
 import { capitalCase } from 'change-case';
 import { planeTintItemName, objectiveMark } from '../utilities/planes.js';
+import { dataDevices } from '../utilities/data-library.js';
 /**
  * On-demand inventory panel, replacing the always-on blessed sidebar box
  * (same freeing-up-the-log treatment as equipment.ts and map.ts -- the
@@ -122,6 +123,19 @@ export class InventoryCommand extends Command {
                     lines.push(legend);
             }
         }
+        // THE DEVICE LIBRARIES (digital inventory, 2026-10-04): data you have
+        // copied lives on a device, not in the pack -- so the pack view says
+        // where it is, device by device, or it reads as lost.
+        const libraries = dataDevices(actor).filter(d => d.files.length > 0);
+        if (libraries.length > 0) {
+            lines.push('', `{light-blue-fg}On your devices:{/light-blue-fg}`);
+            for (const device of libraries) {
+                lines.push(`  ${device.name}: ${device.files.map(f => `${objectiveMark(this.scene, f.name)}${planeTintItemName(f, 'meat')}`).join(', ')}`);
+            }
+            const legend = hint(`("transfer <file> to <device>" moves one; "transfer <file> to chip" writes it to physical media.)`);
+            if (legend)
+                lines.push(legend);
+        }
         return lines.join('\n');
     }
 }

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

@@ -25,6 +25,7 @@ import { showsMechanics, mechanicsActorPrefix } from '../utilities/mechanics-aud
 import { spotHiddenIcons, spotLine, spotMechanics } from '../utilities/silent-icons.js';
 import { personasInside } from '../utilities/matrix-roster.js';
 import { crowdLine } from '../utilities/crowd.js';
+import { findDeviceFile } from '../utilities/data-library.js';
 export class LookCommand extends Command {
     static verb = 'look';
     static description = 'Examine your surroundings';
@@ -135,6 +136,13 @@ export class LookCommand extends Command {
                 this.logger.write(`Looking at equipped item '${worn.name}' on ${this.actor.name}.`);
                 return this.describeItem(worn, target);
             }
+            else if (findDeviceFile(this.actor, target)) {
+                // A FILE ON YOUR DEVICE (digital inventory, 2026-10-04): your own
+                // library reads like your own bag.
+                const held = findDeviceFile(this.actor, target);
+                this.logger.write(`Looking at file '${held.file.name}' on ${held.device?.name}.`);
+                return this.describeItem(held.file, target);
+            }
             else if (this.actor.currentLocation.inventory.hasItem(target)) {
                 this.logger.write(`Looking at item '${target}' in current room inventory.`);
                 return this.inspectItem(target, this.actor.currentLocation.inventory);
@@ -495,6 +503,10 @@ export class LookCommand extends Command {
         if (carried?.plane === 'matrix') {
             return this.inspectItem(target, this.actor.inventory);
         }
+        // Your own device's library (digital inventory, 2026-10-04).
+        const onDevice = findDeviceFile(this.actor, target);
+        if (onDevice)
+            return this.describeItem(onDevice.file, target);
         const onGrid = room.inventory.getItem(target);
         if (onGrid?.plane === 'matrix') {
             const reach = fileReach(this.actor, room);

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

@@ -1,10 +1,6 @@
 import { Command } from './command.js';
-import { whereIsThat } from '../utilities/matrix-roster.js';
-import { gridVicinity, hostDoorOpenFor } from '../utilities/grid-reach.js';
-import { fileReach } from '../utilities/planes.js';
 import { canReach, ensureAtSpot, sealedRouteTo } from '../utilities/spots.js';
 import { hint } from '../utilities/hints.js';
-import { Category } from '../types/shared/item-enum.js';
 import { billAction } from '../utilities/action-cost.js';
 export class TakeCommand extends Command {
     static verb = 'take';
@@ -29,6 +25,21 @@ export class TakeCommand extends Command {
                 screen: this.screen, game: this.game,
             }).execute();
         }
+        // A PERSONA HAS NO HANDS -- IT COPIES (digital inventory, user ruling
+        // 2026-10-04). On the Matrix plane "take" is the download: Edit File's
+        // copy (p.239) into your device's library, not Pick Up Object into the
+        // pack. One path, commands/download.ts, so the two verbs cannot drift
+        // (they had: download read an uncracked host's archive take refused).
+        if (this.actor.plane === 'matrix') {
+            const { DownloadCommand } = await import('./download.js');
+            const download = new DownloadCommand({
+                actor: this.actor, scene: this.scene, rooms: this.rooms,
+                screen: this.screen, game: this.game,
+            });
+            if (wanted === 'all' || wanted === 'everything')
+                return download.pullAll();
+            return download.execute(args);
+        }
         // PICK UP OBJECT (SR5 p.165): a Simple Action in a Combat Turn.
         const bill = billAction(this.scene, this.actor, 'simple', 'Pick Up Object');
         if (bill)
@@ -119,7 +130,8 @@ export class TakeCommand extends Command {
      * would.
      */
     takeAll() {
-        const room = this.actor.plane === 'matrix' ? gridVicinity(this.actor) : this.actor.currentLocation;
+        // The Matrix plane never reaches here -- execute() routes it to download.
+        const room = this.actor.currentLocation;
         // Your plane's items only: an astral form can SEE the meat world's
         // gear but its hands pass straight through; a Matrix persona sweeps
         // files, not furniture.
@@ -131,26 +143,6 @@ export class TakeCommand extends Command {
         if (this.actor.plane === 'drone') {
             return `The ${this.actor.riggedDrone?.name ?? 'drone'} has no hands, and your pack is wherever your body is. Look all you want -- carrying is a meat job.`;
         }
-        // A matrix-plane sweep only ever contains the host's files -- which
-        // live INSIDE the host (p.246) and stay vaulted until it is cracked.
-        // See the single-take gate below for the same rules one item at a
-        // time. The air-gap arm that used to sit here is gone with the model
-        // it belonged to (hhSWzLSXECFtfoAGa).
-        if (this.actor.plane === 'matrix' && (room.hasNode || room.offlineServer)
-            && room.inventory.getAllItems().some(i => i.plane === 'matrix')) {
-            const reach = fileReach(this.actor, room);
-            if (reach === 'connect') {
-                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} (p.233).`;
-            }
-            if (reach === 'enter') {
-                return `Those files are INSIDE the host, and you're out on the grid looking at its shell (p.246). ${hostDoorOpenFor(room, this.actor) ? `"enter" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
-            }
-            // Same split as look.ts: the host's seal does not reach a box that
-            // is not on the network. The air gap IS the server's security.
-            if (room.hasNode && !room.offlineServer && !room.hostCracked) {
-                return `The files here are sealed inside the host's data vault. Crack the node first ("hack") -- then sweep it clean.`;
-            }
-        }
         // You sweep what you've SEEN. Normally that means having searched this
         // room -- but gear that arrived in the open in front of you (a dead
         // NPC's scattered kit, a witnessed drop; see Room.plainSightItems)
@@ -188,25 +180,8 @@ export class TakeCommand extends Command {
         let tookAnything = false;
         const taken = [];
         for (const item of items) {
-            // The sweep skips a file the objective says to ERASE -- see the
-            // single-take refusal below for why a copy is not a fix.
-            const wcAll = this.scene.getWinCondition?.();
-            if (item.plane === 'matrix' && wcAll?.type === 'erase' && wcAll.item?.toLowerCase() === item.name.toLowerCase()) {
-                lines.push(`  • left the {bold}{underline}${item.name}{/underline}{/bold} -- copying it changes nothing; "erase" it`);
-                continue;
-            }
             try {
                 this.actor.addInventory(item);
-                // THE SWEEP DOWNLOADS TOO. Same rule as the single take below,
-                // applied here because a family fixed on one verb and not its
-                // sibling is how the other half of a mechanic goes missing:
-                // "take all" over a cracked host would otherwise leave every
-                // file plane 'matrix' in a pocket no meat hand can reach.
-                const sweptPaydata = item.plane === 'matrix';
-                if (sweptPaydata) {
-                    item.plane = 'meat';
-                    item.category = Category.Datachip;
-                }
                 room.inventory.removeItem(item.name);
                 room.plainSightItems.delete(item.name.toLowerCase());
                 tookAnything = true;
@@ -214,7 +189,7 @@ export class TakeCommand extends Command {
                 // see the theft note on the single-item path below.
                 taken.push(item.owner && item.owner !== this.actor.name ? `${item.name} (${item.owner}'s)` : item.name);
                 this.logger.write(`take all: ${this.actor.name} took "${item.name}" from ${room.name}.`);
-                lines.push(`  • ${sweptPaydata ? `pulled down the {bold}{underline}${item.name}{/underline}{/bold} -- written to a chip` : `took the {bold}{underline}${item.name}{/underline}{/bold}`}`);
+                lines.push(`  • took the {bold}{underline}${item.name}{/underline}{/bold}`);
                 if (item.owner && item.owner !== this.actor.name) {
                     this.scene.addWorldEvent(`${this.actor.name} took ${item.name} (belonging to ${item.owner}) from ${room.name}.`);
                 }
@@ -279,23 +254,8 @@ export class TakeCommand extends Command {
     }
     take(args) {
         const itemName = args?.join(' ').toLowerCase();
-        const room = this.actor.plane === 'matrix' ? gridVicinity(this.actor) : this.actor.currentLocation;
-        // A FILE ELSEWHERE IN THE DISTRICT (matrix model): name it from the grid
-        // and 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.
-        if (this.actor.plane === 'matrix' && !this.actor.insideHost && args.length > 0) {
-            const query = args.join(' ');
-            const here = room.inventory.getAllItems().some(i => i.name.toLowerCase() === query.toLowerCase());
-            const far = here ? undefined : whereIsThat(this.rooms ?? this.scene.getRooms(), this.actor, query);
-            if (far && far.room !== room && (far.reach === 'open' || far.remembered)) {
-                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, this.actor) ? `"enter ${far.room.name}" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
-                if (far.reach === 'open')
-                    return `${far.item.name} is loose on the grid -- a dim icon. ${hint(`"download ${far.item.name}" writes it to a chip from here.`)}`;
-            }
-        }
+        // The Matrix plane never reaches here -- execute() routes it to download.
+        const room = this.actor.currentLocation;
         // Check if the item exists in the room's inventory
         if (!room.inventory.hasItem(itemName)) {
             this.logger.write(`Item "${itemName}" not found in ${room.name} during 'Take' command.`);
@@ -321,39 +281,6 @@ export class TakeCommand extends Command {
                 ? `The ${itemName} is DATA -- it only exists on the grid. Jack in to take it.`
                 : `The ${itemName} isn't reachable from this plane.`;
         }
-        // THE HOST IS THE VAULT, AND YOU HAVE TO BE IN IT. Two separate
-        // gates, and they are not the same one: being INSIDE (p.246) is
-        // where the file is, and CRACKED (a mark buys the door, p.239, not
-        // the contents) is whether the seal is off. A persona who marked a
-        // host and walked in still finds the archive locked.
-        //
-        // This take path is load-bearing for the data-run win condition (s3
-        // builds on it): taking a matrix file is the DOWNLOAD, and the item
-        // keeps its name on the way out because the objective matches on
-        // that name. Do not rename items here.
-        if (item.plane === 'matrix' && (room.hasNode || room.offlineServer)) {
-            const reach = fileReach(this.actor, room);
-            if (reach === 'connect') {
-                return `The ${item.name} sits on the ${room.offlineServer} -- a box with no Matrix presence at all. No persona reaches it from anywhere: get your BODY into ${room.name} and cable in (p.233).`;
-            }
-            if (reach === 'enter') {
-                return `The ${item.name} is INSIDE the host -- you're on the outside grid, reading its shell (p.246). ${hostDoorOpenFor(room, this.actor) ? `"enter" first.` : `Get a mark on it and "enter" -- or "hack" your way in.`}`;
-            }
-            // A LOOSE END IS ERASED, NOT CARRIED (win-condition-seed.ts 'erase',
-            // 2026-09-14): pulling the footage down to a chip leaves the desk's
-            // copy exactly where it was, and would let a runner believe the
-            // night was dealt with. The objective's own verb is "erase" --
-            // said before the seal, because it is the refusal that teaches.
-            const wc = this.scene.getWinCondition?.();
-            if (wc?.type === 'erase' && wc.item?.toLowerCase() === item.name.toLowerCase()) {
-                return `Copying ${item.name} changes nothing -- the desk keeps its own. ${hint(`"erase ${item.name}" is what makes it go away (Edit File, p.239).`)}`;
-            }
-            // Same split as look.ts: the host's seal does not reach a box that
-            // is not on the network. The air gap IS the server's security.
-            if (room.hasNode && !room.offlineServer && !room.hostCracked) {
-                return `The ${item.name} is sealed inside the host's data vault. Crack the node first ("hack") -- then it's yours.`;
-            }
-        }
         // "At" spots: hands need to be where the goods are -- out of combat
         // that's a free walk over (utilities/spots.ts ensureAtSpot).
         const reach = ensureAtSpot(this.actor, item.atSpot);
@@ -372,35 +299,6 @@ export class TakeCommand extends Command {
             this.actor.performAction('takes', item.owner && item.owner !== this.actor.name ? `${item.name} (${item.owner}'s)` : item.name);
             this.actor.addInventory(item);
             this.logger.write(`Successfully added "${itemName}" to ${this.actor.name}'s inventory during 'Take' command.`);
-            // PAYDATA COMES HOME ON A CHIP (user ruling 2026-08-30, for the
-            // data-run type ruoedrMTA6kCRNmEN).
-            //
-            // Lifting a file used to leave it plane 'matrix' IN YOUR POCKET:
-            // carried by a persona, invisible to your meat hands the moment
-            // you jacked out, and impossible to hand to a fixer who has never
-            // been on the grid in his life. The data was yours and there was
-            // no way to spend it.
-            //
-            // So the download is the take. The file is written to physical
-            // media the instant it leaves the host, and what you carry out is
-            // a chip -- which is what a fixer can be handed, and what a
-            // winCondition can name.
-            //
-            // THE NAME IS DELIBERATELY UNCHANGED. A run's objective is matched
-            // by item NAME (win-condition-seed.ts: "must match an items[].name")
-            // so renaming the file on download would break the very run this
-            // exists to complete -- the fiction changes, the identity does not.
-            //
-            // Category moves to Datachip because that is what it now is, and
-            // it is safe: the enum has existed all along with no runtime
-            // consumer -- only generation-time clue validation reads
-            // categories, and that has already run by the time anyone takes
-            // anything.
-            const wasPaydata = item.plane === 'matrix';
-            if (wasPaydata) {
-                item.plane = 'meat';
-                item.category = Category.Datachip;
-            }
             if (item.owner && item.owner !== this.actor.name) {
                 this.scene.addWorldEvent(`${this.actor.name} took ${item.name} (belonging to ${item.owner}) from ${room.name}.`);
             }
@@ -427,12 +325,7 @@ export class TakeCommand extends Command {
             // render BEFORE it -- print directly for the player, return the text
             // for an NPC actor's AI history.
             const isPlayer = this.scene.isHumanControlled(this.actor);
-            // The download is worth SAYING, not just doing: a player who lifts
-            // a file and is told "you have taken it" has no way to know the
-            // thing in their pocket is now something a fixer can be handed.
-            const taken = wasPaydata
-                ? `You pull the ${itemName} down out of the host and write it to a chip -- physical media, in your hand, off the grid.`
-                : `You have taken the ${itemName}.`;
+            const taken = `You have taken the ${itemName}.`;
             if (isPlayer) {
                 this.logger.log(taken);
             }

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

@@ -0,0 +1,92 @@
+import { Command } from './command.js';
+import { hint } from '../utilities/hints.js';
+import { fuzzyPickName } from '../utilities/fuzzy-match.js';
+import { burnToChip, dataChips, dataDevices, deviceFiles, deviceHas, fileOnto, findDataDevice, findDeviceFile, loadChip, } from '../utilities/data-library.js';
+/**
+ * "transfer <file> to <device|chip>" -- MOVE DATA AROUND YOUR OWN PAN.
+ *
+ * Digital inventory (user ruling 2026-10-04). Three moves, all FREE -- no
+ * action, no test:
+ *   - device to device: canon is silent on whether an owner (four marks'
+ *     worth, p.236) rolls Edit File against their own Firewall, and the
+ *     user ruled the reshuffle free;
+ *   - device to chip: the file is written to a physical datachip in the
+ *     pack and leaves the library -- physical media in one move, never an
+ *     extra step a delivery demands;
+ *   - chip to device: the chip is read onto the device and consumed.
+ *
+ * These are moves, not copies: a file you shuffle between your own
+ * devices does not multiply. Copies come from Edit File against somebody
+ * else's archive (download / upload).
+ */
+export class TransferCommand extends Command {
+    static verb = 'transfer';
+    static description = 'Move a file between your own devices, or onto a physical datachip and back -- "transfer <file> to <device>" / "transfer <file> to chip". Free: no action, no test (your own gear). "inv" shows what each device holds.';
+    async execute(args = []) {
+        const actor = this.actor;
+        const said = args.join(' ').trim();
+        const m = said.match(/^(.*)\s+(?:to|onto|into)\s+(?:a\s+|the\s+|my\s+)?(.+)$/i);
+        if (!m) {
+            const files = deviceFiles(actor).map(h => `${h.file.name} (${h.device.name})`);
+            const chips = dataChips(actor).map(c => `${c.name} (chip)`);
+            const all = [...files, ...chips];
+            return `Transfer what, to where? ${hint(`("transfer <file> to <device>" or "transfer <file> to chip".${all.length > 0 ? ` You hold: ${all.join(', ')}.` : ''})`)}`;
+        }
+        const query = m[1].trim();
+        const dest = m[2].trim();
+        // TO A CHIP: device file -> physical media in the pack.
+        if (/^(chip|datachip|data chip|a chip|optical chip|physical)$/i.test(dest)) {
+            const held = findDeviceFile(actor, query);
+            if (!held || !held.device) {
+                const already = dataChips(actor).find(c => c.name.toLowerCase() === query.toLowerCase());
+                if (already)
+                    return `${already.name} is already on a chip.`;
+                return `No file called "${query}" on your devices.`;
+            }
+            try {
+                burnToChip(actor, held);
+            }
+            catch {
+                return `Your pack can't take the chip -- ${held.file.name} stays on your ${held.device.name}.`;
+            }
+            this.logger.write(`${actor.name} burned "${held.file.name}" from ${held.device.name} to a chip.`);
+            this.game?.requestSave('data');
+            this.scene.updateStatus();
+            return `You write ${held.file.name} out to a datachip -- physical media in your pack now, off your ${held.device.name}.`;
+        }
+        const device = findDataDevice(actor, dest);
+        if (!device) {
+            const devices = dataDevices(actor);
+            return `You carry no device called "${dest}".${devices.length > 0 ? hint(` (Yours: ${devices.map(d => d.name).join(', ')} -- or a chip.)`) : ''}`;
+        }
+        // FROM A DEVICE (or, failing that, a chip) TO THIS DEVICE.
+        const fromDevice = findDeviceFile(actor, query);
+        const chips = dataChips(actor);
+        const chipName = fromDevice ? undefined : fuzzyPickName(query, chips.map(c => c.name));
+        const chip = chipName ? chips.find(c => c.name === chipName) : undefined;
+        if (!fromDevice && !chip) {
+            return `No file called "${query}" on your devices or on a chip in your pack.`;
+        }
+        const file = fromDevice ? fromDevice.file : chip;
+        if (fromDevice?.device === device)
+            return `${file.name} is already on your ${device.name}.`;
+        if (deviceHas(device, file.name))
+            return `Your ${device.name} already holds a file called ${file.name}.`;
+        if (fromDevice && fromDevice.device) {
+            const at = fromDevice.device.files.indexOf(file);
+            fromDevice.device.files.splice(at, 1);
+            fileOnto(device, file);
+            actor.noteConditionChanged();
+            this.logger.write(`${actor.name} moved "${file.name}" from ${fromDevice.device.name} to ${device.name}.`);
+            this.game?.requestSave('data');
+            this.scene.updateStatus();
+            return `${file.name} slides across your PAN from the ${fromDevice.device.name} to the ${device.name}.`;
+        }
+        loadChip(actor, chip, device);
+        this.logger.write(`${actor.name} read chip "${chip.name}" onto ${device.name}.`);
+        this.game?.requestSave('data');
+        this.scene.updateStatus();
+        return `You slot the chip and read ${chip.name} onto your ${device.name} -- the chip is blank now, and you toss it.`;
+    }
+}
+//# sourceMappingURL=transfer.js.map

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

@@ -0,0 +1,108 @@
+import { Command } from './command.js';
+import { billAction } from '../utilities/action-cost.js';
+import { hint } from '../utilities/hints.js';
+import { hostLabel } from '../utilities/grid-names.js';
+import { editFileBlocked, rollEditFile } from '../utilities/edit-file-test.js';
+import { copyFile, deviceFiles, findDeviceFile, dataChips } from '../utilities/data-library.js';
+/**
+ * "upload" -- WRITE A FILE FROM YOUR DEVICE ONTO THE HOST YOU STAND IN.
+ *
+ * Digital inventory (user ruling 2026-10-04): data moves between
+ * libraries, and a host's archive is one (models/host.ts addFile). The
+ * action is Edit File's CREATE -- SR5 p.239: "Edit File allows you to
+ * create, change, copy, delete, or protect any kind of file. The defender
+ * against this test is either the host holding the file or the owner" --
+ * Computer + Logic [Data Processing] v. the host, Marks Required 1, a
+ * Complex Action. The roll is utilities/edit-file-test.ts, the one erase
+ * and download make.
+ *
+ * The same two engine rulings download.ts names hold here: a persona
+ * edits a host's files from INSIDE it (the host keeps them; canon does
+ * not say how a file in a host is marked, only archive files carry marks,
+ * p.247), and a CRACKED host (three marks, hack.ts) treats you as staff,
+ * so writing to it takes no roll.
+ *
+ * Like the download it is a COPY: what lands on the host is a fresh file,
+ * and your device keeps its own (p.239's copy, run the other way).
+ *
+ * THE COURIER (win-condition 'upload'): a file planted on the right host
+ * is the delivery. scene.checkUploaded decides, and is told whether the
+ * host was on alert when the file arrived -- the harder jobs want it in
+ * unseen.
+ */
+export class UploadCommand extends Command {
+    static verb = 'upload';
+    static description = 'Write a file from your device onto the host you are inside -- "upload <file>". 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. Your device keeps its copy. A courier job is done when its file lands on the right host.';
+    async execute(args = []) {
+        const actor = this.actor;
+        // "upload X to host" / "upload X into the host": the destination is
+        // always the host you are in, so the tail is decoration.
+        const query = args.join(' ').replace(/\s+(?:to|onto|into)\s+(?:the\s+)?host\b.*$/i, '').trim();
+        if (actor.plane !== 'matrix') {
+            return `Files go onto a host from the Matrix. ${hint(`"jack in", then "enter" the host.`)}`;
+        }
+        const host = actor.hostInside;
+        if (!host) {
+            return `You write to a host from INSIDE it (p.246). ${hint(`"enter" the host first.`)}`;
+        }
+        const room = host.over;
+        const mine = deviceFiles(actor);
+        if (!query) {
+            if (mine.length === 0) {
+                return dataChips(actor).length > 0
+                    ? `Nothing on your devices to upload. ${hint(`(A chip in your pack has to go onto a device first: "transfer <file> to <device>".)`)}`
+                    : `Nothing on your devices to upload.`;
+            }
+            return `Upload which file? ${hint(`(On your devices: ${mine.map(h => h.file.name).join(', ')}.)`)}`;
+        }
+        const held = findDeviceFile(actor, query);
+        if (!held || !held.device) {
+            const chip = dataChips(actor).find(c => c.name.toLowerCase() === query.toLowerCase());
+            if (chip)
+                return `${chip.name} is on a chip in your pack, not on a device. ${hint(`"transfer ${chip.name} to <device>" first -- it costs nothing.`)}`;
+            return `No file called "${query}" on your devices.${mine.length > 0 ? hint(` (They hold: ${mine.map(h => h.file.name).join(', ')}.)`) : ''}`;
+        }
+        const file = held.file;
+        if (host.hasFile(file.name)) {
+            return `${hostLabel(room, { capital: true })} already holds a file called ${file.name}.`;
+        }
+        const needsRoll = !host.cracked;
+        if (needsRoll && (host.marksBy.get(actor.name) ?? 0) < 1) {
+            return `Edit File needs a MARK (p.239) -- you hold none on ${hostLabel(room)}. ${hint(`"hack" the host for one.`)}`;
+        }
+        if (needsRoll) {
+            const burned = editFileBlocked(actor);
+            if (burned)
+                return burned;
+        }
+        const bill = billAction(this.scene, actor, 'complex', 'Edit File (create)');
+        if (bill)
+            return bill;
+        actor.performAction('edits a file', `${file.name} into ${hostLabel(room)}`, { quiet: this.scene.isHumanControlled(actor) });
+        if (needsRoll) {
+            const roll = rollEditFile(this.scene, this.logger, actor, host, 'create');
+            if (!roll.success) {
+                this.logger.write(`${actor.name} failed to upload "${file.name}" to ${room.name}: ${roll.hits} v ${roll.defence}.`);
+                return `The write bounces -- ${hostLabel(room)}'s file system refuses the new entry and ${file.name} stays on your ${held.device.name} alone. A failed edit is not a failed sleaze; nobody upstairs noticed.${hint(` (Try again; each attempt is a Complex Action.)`)}`;
+            }
+        }
+        // The host's copy; yours stays where it was (p.239).
+        const landed = copyFile(file);
+        host.addFile(landed);
+        // Fresh on the archive and written by you: you have seen it land.
+        host.searchedBy.add(actor.name);
+        this.logger.write(`${actor.name} uploaded "${file.name}" from ${held.device.name} to ${room.name}'s host${host.alert ? ' (host on alert)' : ''}.`);
+        this.game?.requestSave('data');
+        const text = `{light-blue-fg}You write {bold}{underline}${file.name}{/underline}{/bold} into ${hostLabel(room)} -- a new entry in its index, checksum agreeing. Your ${held.device.name} keeps its copy.{/light-blue-fg}`;
+        // ORDER, as take.ts does it: the objective check prints its own
+        // banner, so the write renders first and the verb returns nothing for
+        // a human; an NPC gets the text back for its AI history.
+        const isPlayer = this.scene.isHumanControlled(actor);
+        if (isPlayer)
+            this.logger.log(text, { actor: actor.name });
+        this.scene.checkUploaded?.(file.name, room.name, actor.name, host.alert);
+        this.scene.updateStatus();
+        return isPlayer ? '' : text;
+    }
+}
+//# sourceMappingURL=upload.js.map

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

@@ -3235,5 +3235,23 @@
 // - The street doc is told how the patient is in a body's words and is
 //   barred from "boxes" and other screen terms, in the treat note and in
 //   the brief (7G2avXprhjrawdc7L: "three boxes left ... breaks the fiction").
-export const ENGINE_VERSION = '1.190.0';
+// 1.191.0 (2026-10-04): DIGITAL INVENTORY (user ruling 2026-10-04).
+// - Commlinks, decks and RCCs carry a data library (Item.files, saved);
+//   matrix take/download COPY a file into it (Edit File, p.239) -- the
+//   host keeps its original, and an uncracked host makes the copy an
+//   Edit File test with a mark. No more chip on download.
+// - upload (Edit File create) writes a device file onto the host you
+//   are in; transfer moves files between your devices or onto/off a
+//   datachip, free. give / call deliver straight from a device.
+// - The data courier: delivery + data run = win-condition 'upload' (a
+//   file to a host; large/epic must land unseen). The client pushes the
+//   cargo onto the runner's device at the meet.
+// - The gear beat carries data (device libraries) and host (the found
+//   archive of the host the persona is in).
+// 1.191.1 (2026-10-04): A LIVING PERSONA HAS NO STORAGE (SR5 p.250-251).
+// - A download with no commlink, deck or RCC to land on is refused, not
+//   written to a chip -- a persona is not a device, and a datachip has no
+//   wireless to write through. Reaches only the deviceless technomancer;
+//   one with a commlink copies onto it and keeps their Resonance.
+export const ENGINE_VERSION = '1.191.1';
 //# sourceMappingURL=engine-version.js.map

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

@@ -18,17 +18,37 @@ export function pickJobKind(roll = Math.random(), coin = Math.random()) {
         return 'extraction';
     return 'delivery';
 }
-/** Only a datasteal can be a data run: the other kinds have no file to
- *  take. A rolled or asked-for 'data' on any other kind is dropped. */
+/** A datasteal or a delivery can be a data run: the steal's prize is a
+ *  file on a host, the delivery's package is a file for one (the data
+ *  courier, user ruling 2026-10-04 -- win-condition 'upload'). The other
+ *  kinds have no file, so a rolled or asked-for 'data' is dropped. */
 export function shapeFor(kind, runType) {
-    return kind === 'datasteal' ? runType : 'standard';
+    return kind === 'datasteal' || kind === 'delivery' ? runType : 'standard';
+}
+/**
+ * THE DATA COURIER (user ruling 2026-10-04): a delivery whose package is a
+ * FILE and whose drop is a HOST. The client pushes the file onto the
+ * runner's device at the meet; the runner gets inside the target host
+ * and uploads it (commands/upload.ts, Edit File's create, p.239).
+ */
+export function isDataCourier(kind, runType) {
+    return kind === 'delivery' && runType === 'data';
+}
+/**
+ * Does a courier's plant have to land UNSEEN? The harder jobs say so
+ * (user ruling 2026-10-04: "1 for simpler jobs, and 2 for harder jobs"):
+ * large and epic want the file in before the host knows anyone is there;
+ * small and medium only want it there.
+ */
+export function courierMustBeUnseen(size) {
+    return size === 'large' || size === 'epic';
 }
 const KIND_WORDS = [
     { kind: 'assassination', rx: /\b(wetwork|wet\s*work|wet\s*job|assassinat\w*|a hit|hit job|kill(ing)? (job|work|someone|somebody)|take (someone|somebody) out|put (someone|somebody) down)\b/i },
     { kind: 'destruction', rx: /\b(destroy\w*|destruction|demolition|demolish\w*|sabotage|wreck\w*|blow (something|it|it all) up|torch (job|work|something)|break (something|stuff|shit))\b/i },
     { kind: 'extraction', rx: /\b(extract\w*|pull (someone|somebody|a guy|a girl|them|him|her) out|get (someone|somebody|them|him|her) out|snatch (someone|somebody|a person)|kidnap\w*|defect\w*|exfil\w*)\b/i },
     { kind: 'extraction', rx: /\b(extract\w*|pull (someone|somebody|a guy|a girl|them|him|her) out|get (someone|somebody|them|him|her) out|snatch (someone|somebody|a person)|kidnap\w*|defect\w*|exfil\w*)\b/i },
-    { kind: 'delivery', rx: /\b(deliver\w*|courier|smuggl\w*|run (a|the|this) package|package run|cargo|transport (job|work|run))\b/i },
+    { kind: 'delivery', rx: /\b(deliver\w*|courier|smuggl\w*|run (a|the|this) package|package run|cargo|transport (job|work|run)|upload\w*|plant\w*\s+(a\s+|the\s+|some\s+)?(file|data|worm|backdoor))\b/i },
     { kind: 'datasteal', rx: /\b(datasteal|data\s*steal|steal\w*|snatch|grab (job|work|a thing)|burglary|retrieval|paydata|data\s*(work|run|runs|job|jobs|dive|diving))\b/i },
 ];
 /** The job type a line of speech asks for, if it names one. */
@@ -252,6 +272,10 @@ export function objectiveRoomFor(skeleton) {
     const wc = skeleton.winCondition;
     if (!wc)
         return undefined;
+    // A courier's objective is the DROP host's room, not the client who
+    // holds the cargo at the meet.
+    if (wc.item && wc.target)
+        return wc.target;
     if (wc.item) {
         const win = skeleton.items.find(i => i.name === wc.item);
         return win?.room ?? skeleton.npcs.find(n => n.name === win?.heldBy)?.startLocation;