@maka/maka-cli 5.197.0 → 5.199.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/narration-limits.js

@@ -0,0 +1,235 @@
+/**
+ * WHAT A BEAT MAY CLAIM (aCErAfvEW7G23FWDM).
+ *
+ * THE LINE THIS EXISTS FOR, from session 2026-09-15T14-45-01-617Z at
+ * 11:05:43, three seconds after the player typed "jack in":
+ *
+ *   "Ms. Quill plants a hand on Ted's shoulder, not gentle, steering
+ *    him toward the door before Kessler decides to make this paperwork."
+ *
+ * Nothing happened. No dice were rolled, no defence was offered, no
+ * Combat Turn opened, and Ted -- who was on the Ares grid with his body
+ * slumped in a bar -- had no way to answer any of it. The sentence was
+ * EXPOSITION: a non-command line of a model reply, printed to the
+ * player verbatim (models/npc.ts). The engine never saw an act at all,
+ * which is why no rule caught it.
+ *
+ * THE REPORTER'S OWN RULE, which is the one implemented here: "'plants
+ * hand on Ted's shoulder' is an emote, and that's fine, but moving
+ * someone against their will is a hostile action, and should start some
+ * sort of combat."
+ *
+ * So the boundary is not violence and it is not touch. It is AGENCY
+ * OVER SOMEBODY ELSE'S BODY. A beat may do anything it likes with the
+ * NPC's own body, mood, tone, props and surroundings -- that is the
+ * writing, and the writing is good. It may not move, hold, or lay hands
+ * on another actor, because those have mechanics (SR5 p.195 Subduing,
+ * resolved as an opposed Unarmed melee attack) and prose is not allowed
+ * to skip them.
+ *
+ * WHAT HAPPENS TO A CAUGHT LINE. It is suppressed and the NPC is told
+ * why, in the same breath, so the next beat can COMMIT to the act as a
+ * command instead of asserting it as a fact -- where the authorization
+ * gate, the dice and the Combat Turn all get their say. Refusing
+ * silently would just produce a mute NPC and a confused model.
+ *
+ * WHY A PREDICATE AND NOT A MODEL INSTRUCTION. The prompt has told the
+ * model to behave for a long time; it says "Do NOT repeat, rephrase, or
+ * re-ask" and the same session has an NPC delivering one hook twice in
+ * two phrasings. An instruction is advice. This is the engine.
+ *
+ * Exported and PURE for the same reason isOutOfCharacter is: it fails
+ * silently -- a pattern that stops matching does not throw, the line
+ * simply prints, and the only detector is a player watching their
+ * Johnson march them out of a bar they were not standing in.
+ */
+/**
+ * PUTTING HANDS ON SOMEBODY. Deliberately anchored on the ACT, not on
+ * the body part: "a hand on their shoulder" and "a hand on their arm"
+ * are the same claim, and enumerating anatomy is how a list like this
+ * rots.
+ *
+ * `grabs|seizes|...` carry their inflections because a beat is written
+ * in the present tense but a reflect line may not be.
+ */
+const CONTACT = new RegExp([
+    // "plants/lays/claps/puts/sets a hand on", and the bare "a hand on".
+    String.raw `\b(?:plant|lay|lays|clap|put|puts|set|sets|place|places|rest|rests|drop|drops)\w*\s+(?:a|her|his|their|one)\s+hands?\s+(?:on|against|to)\b`,
+    // "...hand closes around", whoever the hand belongs to. No determiner
+    // required: the fiction writes "Quill's hand closes around Ted's arm"
+    // as readily as "a hand closes", and both are the same claim.
+    String.raw `\bhands?\s+(?:lands?|closes?|clamps?|settles?|falls?|tightens?|locks?)\s+(?:on|around|over|about)\b`,
+    // Seizing and holding.
+    String.raw `\b(?:grab|grabs|grabbed|grabbing|seiz\w+|grip\w*|clutch\w*|clamp\w*|catch\w*|snatch\w*|takes?\s+hold|gets?\s+(?:a\s+)?(?:hand|grip|hold))\b`,
+    String.raw `\b(?:restrain\w*|pin\w*|wrestl\w*|manhandl\w*|hold\w*\s+(?:down|back|still))\b`,
+    // "holds Maka pinned", where the person sits BETWEEN the verb and the
+    // word that makes it a hold. The aimed-at test reads forward from a
+    // match, so the name has to be inside the match for this shape --
+    // found by sweeping the transcripts, where it is how a continuing
+    // grapple is always written.
+    String.raw `\bhold\w*\s+\w+(?:'s|’s)?\s*(?:pinned|down|still|fast|against|in place)\b`,
+    // Striking, shoving -- these ARE attacks and have their own verbs.
+    String.raw `\b(?:shov\w+|push\w*|punch\w*|slap\w*|strik\w+|kick\w*|slam\w*|throw\w*)\b`,
+    // "takes/catches them by the arm" -- the classic escort grip.
+    String.raw `\b(?:take|takes|took|catch|catches|caught|hook|hooks)\s+\w+(?:'s|’s)?\s*\w*\s+by\s+the\s+\w+`,
+].join('|'), 'i');
+/**
+ * MOVING SOMEBODY WHO DID NOT CHOOSE TO MOVE. The engine has no
+ * compelled-movement mechanic at all -- nothing anywhere writes another
+ * actor's position, and `follow` is opt-in with a leash that breaks the
+ * moment you are grappled. So this is not "use the other verb", it is
+ * "this cannot happen": the canon answer to wanting someone somewhere
+ * else is to hold them (p.195) and let them decide.
+ */
+const COMPELLED_MOVEMENT = new RegExp([
+    // INFLECTED FORMS ONLY for the ones whose stem is also a common NOUN.
+    // `bundl\w+` matched the item "Street Ammo Bundle" and turned a vendor
+    // receipt into an abduction; `herd` and `hustle` are nouns too. Same
+    // lesson as `tow` below, found the same way -- by sweeping the gate
+    // over every transcript on disk rather than by reading the pattern.
+    String.raw `\b(?:steer\w*|guid\w+|shepherd\w*|usher\w*|escort\w*|march\w*|propel\w*|herd(?:s|ed|ing)|bundl(?:es|ed|ing)|hustl(?:es|ed|ing)|hurr(?:y|ies|ied|ying))\b`,
+    // `tow` is spelled out rather than stemmed: `tow\w*` matches TOWARD,
+    // which appears in half the good lines in any transcript and quietly
+    // turned "slides a cred stick across the table toward Ted" into an
+    // abduction. A stem is only safe when no innocent word starts with it.
+    String.raw `\b(?:drag\w*|haul\w*|pull\w*|tug\w*|yank\w*|tows?|towed|towing|carr(?:y|ies|ied|ying)|lift\w*)\b`,
+    String.raw `\b(?:walk\w*|mov\w+|lead\w*|tak\w+)\s+\w+\s+(?:toward|towards|to|out|off|away|through|into|back)\b`,
+].join('|'), 'i');
+const ALLOWED = { refused: false };
+/**
+ * THE WORDS OF A NAME THAT CAN STAND FOR IT.
+ *
+ * "Ms. Quill" is abbreviated to "Quill" in every transcript, so a name
+ * has to match on its parts -- but ONLY the parts that identify
+ * somebody. A scene may legitimately hold an NPC called "The Drowned
+ * Choir" or a bar called "The Blind Eye", and letting "The" stand for
+ * either turns every "the cup" in the room into a person. Found by
+ * sweeping the gate over every transcript on disk: it was the last
+ * false positive left standing.
+ */
+const NOT_A_NAME = /^(?:the|and|of|an|mr|ms|mrs|dr|de|la|le|van|von)\.?$/i;
+function nameForms(name) {
+    const parts = name.split(/\s+/).filter(p => p.length > 2 && !NOT_A_NAME.test(p));
+    return [name, ...parts].map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+}
+/**
+ * A possessive or object mention of somebody who is NOT the speaker.
+ *
+ * Names, not pronouns, and that is the whole reason this is tractable.
+ * A beat that says "steering him toward the door" with no name in it
+ * has no referent the engine can check, so it is left alone -- the
+ * reported line is caught because it says "Ted's shoulder" and
+ * "steering him" in ONE sentence, which is how these are actually
+ * written. Chasing pronouns across sentences would cost far more
+ * false positives than it would catch real ones.
+ */
+function subjectIn(line, others) {
+    for (const name of others) {
+        if (!name)
+            continue;
+        const forms = nameForms(name);
+        const re = new RegExp(`(?:^|[^\\w])(?:${forms.join('|')})(?:'s|’s)?(?:[^\\w]|$)`, 'i');
+        if (re.test(line))
+            return name;
+    }
+    return undefined;
+}
+/**
+ * DOES THE VERB LAND ON THIS PERSON?
+ *
+ * THE FALSE POSITIVES THIS EXISTS FOR, every one a verbatim line from a
+ * real session:
+ *   "Ms. Veil lifts the cup, watches Jynx over its rim."
+ *   "Jynx holds the camera out; Mr. Ibis snatches it up with both hands."
+ *   "Rhen pushes off the wall, inching toward the doorway where Vek stands."
+ *   "Brick's cyber-arms whir, the ledger clutched in his hands."
+ * Each has a contact verb AND somebody else's name, and each is good
+ * writing about an OBJECT or about the speaker's own body. A name
+ * somewhere in the sentence is not enough.
+ *
+ * Approximate and deliberately so: what follows a verb within a few
+ * words is its object far more often than not, and the alternative is
+ * a parser. Two shapes count as aimed at somebody:
+ *
+ *   1. the name (or an object pronoun) inside the next ~30 characters
+ *      -- "grabs Ted", "steers him toward the door", "holds Maka pinned";
+ *   2. the possessive-plus-body-part form the hand patterns produce --
+ *      "a hand on Ted's shoulder", where the name follows a preposition.
+ *
+ * "lifts the cup", "snatches it up" and "pushes off the wall" match
+ * neither, which is the entire point.
+ */
+function aimedAtAPerson(text, matches, subject) {
+    const target = new RegExp(`(?:${nameForms(subject).join('|')})|\\b(?:him|her|them|themselves)\\b`, 'i');
+    for (const m of matches) {
+        if (!m || m.index === undefined)
+            continue;
+        // THE MATCH ITSELF COUNTS, because some patterns swallow their own
+        // object: the compelled-movement rule is written as
+        // "walk|move|lead|take <something> toward", so in "walks Ted toward
+        // the door" the name is INSIDE the match and everything after it is
+        // furniture.
+        //
+        // SIXTEEN CHARACTERS, about three words, and the number is doing
+        // real work rather than being round. At thirty, "Ms. Veil lifts the
+        // cup, watches Jynx over its rim" reaches Jynx and a lovely line
+        // dies; at sixteen it does not, while "grabs Ted by the collar" and
+        // "steering him toward the door" both still land.
+        const end = m.index + m[0].length;
+        if (target.test(m[0] + text.slice(end, end + 16)))
+            return true;
+    }
+    return false;
+}
+/**
+ * MAY THIS BEAT SAY THIS?
+ *
+ * @param line     one exposition line of a model reply
+ * @param speaker  the NPC whose beat it is
+ * @param others   every other actor present, by name
+ * @param opts.holding  who this NPC already has a grapple on, if anyone --
+ *                 narration about a hold the dice already settled is a
+ *                 description, not a claim.
+ */
+export function judgeNarration(line, speaker, others, opts = {}) {
+    const t = line.replace(/^[\s│|>*-]+/, '').trim();
+    if (t.length === 0)
+        return ALLOWED;
+    const contactAt = t.match(CONTACT);
+    const movedAt = t.match(COMPELLED_MOVEMENT);
+    if (!contactAt && !movedAt)
+        return ALLOWED;
+    // WHO IS THE VERB AIMED AT -- asked of EVERY candidate rather than
+    // asked once of whoever is named first.
+    //
+    // Found by sweeping the transcripts: "Brick holds Maka pinned against
+    // the grate, his scarred face grim as he glances at Patches' slumped
+    // form" names two people. Resolving the subject first picked Patches
+    // (merely mentioned), then asked whether the verb was aimed at
+    // Patches, decided no, and let a real hold through. The question has
+    // to be asked per candidate or the answer depends on word order.
+    const subject = others
+        .filter(n => n && n !== speaker)
+        .find(n => subjectIn(t, [n]) && aimedAtAPerson(t, [contactAt, movedAt], n));
+    if (!subject)
+        return ALLOWED;
+    // ALREADY HOLDING THEM. If the engine says this NPC has a grapple on
+    // that target, then "Brick holds Maka pinned against the grate" is
+    // not a claim -- it is a DESCRIPTION of a state the dice already
+    // settled, and refusing it would gag the fiction about the one thing
+    // that IS mechanically true. Measured against every transcript on
+    // disk: without this, three of the nineteen refusals were an NPC
+    // narrating its own real grapple.
+    if (opts.holding && opts.holding === subject)
+        return ALLOWED;
+    // WHICH REFUSAL, because they are different rules with different
+    // answers. Contact has a verb and a rule behind it and the NPC should
+    // be told to use them. Compelled movement has NEITHER -- no mechanic
+    // exists for moving a body that did not choose to move -- so the note
+    // says the true thing rather than naming a verb that will not work.
+    const note = contactAt
+        ? `NARRATION CANNOT PUT HANDS ON ${subject.toUpperCase()}. Your last beat described doing it anyway, so it did not happen and the player was not shown it. Laying hold of someone is an Unarmed attack they get to defend against (Subduing, p.195) and it starts a fight. If you mean it, commit to it: "[COMMAND] grapple ${subject}". If you do not, describe your own body instead -- what your hands do short of touching them is yours to narrate.`
+        : `YOU CANNOT MOVE ${subject.toUpperCase()}. Your last beat described steering or carrying them somewhere, so it did not happen and the player was not shown it. Where a runner's body goes is theirs alone -- there is no way for you to walk them anywhere. Hold them where they stand if you must ("[COMMAND] grapple ${subject}", which starts a fight), ask them to come, or let them stay.`;
+    return { refused: true, subject, note };
+}
+//# sourceMappingURL=narration-limits.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/npc-authorization.js

@@ -0,0 +1,122 @@
+import { fuzzyPickName } from './fuzzy-match.js';
+const ALLOWED = { allowed: true };
+/**
+ * VERBS THAT PUT HANDS ON SOMEONE. The distinction that matters is not
+ * "is this violent" but "does this require the target's body to be
+ * there and able to answer for itself". Subduing (SR5 p.195) is the
+ * canonical one: it deals no damage at all and is still an Unarmed
+ * melee attack the target gets to defend against.
+ */
+const CONTACT_VERBS = new Set([
+    'attack', 'kill', 'subdue', 'grapple', 'restrain', 'clinch', 'struggle',
+    'palm', 'pick',
+]);
+/** Verbs whose first argument names another actor rather than an item
+ *  or a direction. Anything not listed here is authorized on the actor
+ *  alone -- we never guess a target out of an item name. */
+const ACTOR_TARGET_VERBS = new Set([
+    ...CONTACT_VERBS,
+    'cast', 'lead', 'order', 'give', 'talk-to', 'tell', 'treat', 'follow',
+]);
+/**
+ * The target named in the arguments, if this verb names one and the
+ * name resolves to somebody in the room. Deliberately the same fuzzy
+ * resolution the combat verbs use (utilities/fuzzy-match.ts), so a
+ * refusal and an execution disagree about who was meant exactly never.
+ *
+ * Returns undefined when no target is named OR when the name does not
+ * resolve -- an unresolvable name is the COMMAND's business to complain
+ * about ("You don't see X here"), not this module's. Refusing it here
+ * would replace a specific, useful refusal with a vague one.
+ */
+function namedTarget(scene, actor, verb, args) {
+    if (!ACTOR_TARGET_VERBS.has(verb))
+        return undefined;
+    const words = args.filter(w => !/^(the|a|an|at|to|with|from)$/i.test(w));
+    if (words.length === 0)
+        return undefined;
+    const room = actor.currentLocation;
+    if (!room)
+        return undefined;
+    // EVERY actor in the room, not the perceivable ones: this function
+    // answers "who did it mean", and the perception rule below is what
+    // answers "may it". Filtering by perception here would turn "you
+    // cannot see them" into a silent no-target and lose the reason.
+    const candidates = scene.getActorsInRoom(room).filter(a => a !== actor);
+    const picked = fuzzyPickName(words.join(' '), candidates.map(a => a.name));
+    return picked ? candidates.find(a => a.name === picked) : undefined;
+}
+/**
+ * MAY THIS AI-DRIVEN ACTOR RUN THIS COMMAND, RIGHT NOW.
+ *
+ * Called from CommandRegistry.parse for any command declaring
+ * npcPolicy 'authorized', and only for actors the scene does not
+ * consider human-controlled.
+ */
+export function authorizeNpcAction(scene, actor, verb, args) {
+    const target = namedTarget(scene, actor, verb, args);
+    if (!target)
+        return ALLOWED;
+    const contact = CONTACT_VERBS.has(verb);
+    // ORDER MATTERS HERE, and it is a writing decision as much as a rules
+    // one. A jacked-in runner fails BOTH tests below -- cross-plane
+    // perception and body presence -- and the perception rule would fire
+    // first if it were written first, refusing with "you cannot perceive
+    // them". That is true of the PERSONA and useless about the BODY,
+    // which is lying right there in the room and is what the act was
+    // reaching for. For a hands-on verb the absent-body reason is the one
+    // that tells the fiction something it can use.
+    if (contact && !isPresentInBody(target)) {
+        return {
+            allowed: false,
+            reason: `You can't lay hands on ${target.name}: they are not present in their body, and there is nobody home to resist you. Describe what you see, or wait for them to come back.`,
+        };
+    }
+    // YOU CANNOT ACT ON WHAT YOU CANNOT PERCEIVE. The engine's single
+    // cross-plane rule (Player.canPerceive) already gates hear() and
+    // see(), so an NPC never even WAKES for someone on another plane --
+    // but a beat woken by something else could still name them in a
+    // command, and did.
+    if (!actor.canPerceive(target)) {
+        return {
+            allowed: false,
+            reason: `You can't act on ${target.name} -- they are not something you can perceive from where you stand.`,
+        };
+    }
+    if (!contact)
+        return ALLOWED;
+    // LAYING HANDS ON SOMEONE WHO CANNOT ANSWER.
+    //
+    // This is the rung the reported session actually broke, and the
+    // reporter named the rule themselves: an emote is fine, "but moving
+    // someone against their will is a hostile action, and should start
+    // some sort of combat". Ms. Quill planted a hand on Ted's shoulder
+    // and steered him toward the door while Ted was JACKED IN -- a body
+    // slumped in a bar with nobody home to roll a defence.
+    //
+    // SR5 has no rule for this because SR5 assumes a person is present to
+    // defend: Subduing (p.195) is resolved as an opposed melee attack,
+    // and there is nothing to oppose. Rather than invent a defence pool
+    // for an empty body, the engine refuses the act. A runner's unattended
+    // body is not a prop the fiction may move.
+    if (target.isIncapacitated()) {
+        return {
+            allowed: false,
+            reason: `You can't -- ${target.name} is already down and cannot defend themselves.`,
+        };
+    }
+    return ALLOWED;
+}
+/**
+ * Is this actor home? A decker jacked into the Matrix, a magician
+ * projecting astrally and a rigger jumped into a drone all leave a body
+ * behind that is still listed in the room.
+ *
+ * `drone` is deliberately NOT here: a rigger jumped into an airframe is
+ * a physical machine in the meat world with its own defence, and
+ * grabbing one is an ordinary act of violence the engine can resolve.
+ */
+function isPresentInBody(actor) {
+    return actor.plane === 'meat' || actor.plane === 'drone';
+}
+//# sourceMappingURL=npc-authorization.js.map

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

@@ -58,10 +58,10 @@ export function accrueOverwatch(scene, actor, defenseHits, why) {
     // The grid's built-in warning system (p.221): subtle ripples, once
     // per band -- the only free hint the player ever gets.
     if (before < 30 && actor.overwatchScore >= 30) {
-        return { lines: [`{lightblue-fg}The grid RIPPLES -- hard, close, and looking. Something vast has nearly found the thread you're hanging by. ("reboot" is a clean slate.){/lightblue-fg}`], converged: false };
+        return { lines: [`{light-blue-fg}The grid RIPPLES -- hard, close, and looking. Something vast has nearly found the thread you're hanging by. ("reboot" is a clean slate.){/light-blue-fg}`], converged: false };
     }
     if (before < 20 && actor.overwatchScore >= 20) {
-        return { lines: [`{lightblue-fg}A ripple crosses the grid -- subtle, wrong, deliberate. Somewhere above, an eye has started counting your fingerprints.{/lightblue-fg}`], converged: false };
+        return { lines: [`{light-blue-fg}A ripple crosses the grid -- subtle, wrong, deliberate. Somewhere above, an eye has started counting your fingerprints.{/light-blue-fg}`], converged: false };
     }
     return { lines: [], converged: false };
 }

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

@@ -454,7 +454,7 @@ export function fileReach(actor, room) {
  */
 export function planeTintItemName(item, viewerPlane) {
     if (item.plane === 'matrix') {
-        return `{lightblue-fg}${item.name} [data]{/lightblue-fg}`;
+        return `{light-blue-fg}${item.name} [data]{/light-blue-fg}`;
     }
     if (item.plane === 'astral') {
         return `{magenta-fg}${item.name} [astral]{/magenta-fg}`;

package/package.json

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