pf2e-subsystems 0.1.0

package/LICENSE

@@ -0,0 +1,31 @@
+This LICENSE applies to the application CODE of pf2e-subsystems only.
+
+The Pathfinder game content bundled in this package (data/subsystems.generated.js, data/reference.generated.js
+and the inlined copy in dist/index.html — the subsystem, condition and action text)
+is owned by Paizo Inc. and is licensed separately under the ORC and OGL licenses.
+The MIT grant below does NOT cover that content. See notice.md for those terms and
+the required attribution.
+
+----------------------------------------------------------------------
+
+MIT License
+
+Copyright (c) 2026 Whyte Erminae
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,110 @@
+# PF2e Subsystems
+
+A GM-side runner for **Pathfinder 2e (Remaster)** GM Core's Victory Point
+subsystems — the chase, the infiltration, the influence encounter, the research
+montage, and the bare framework underneath all of them.
+
+These are rules that get abandoned mid-session, not because they're hard but
+because tracking them by hand is tedious and easy to get wrong. This keeps the
+bookkeeping honest: awareness ticks up on its own at the end of every round,
+leftover chase points are discarded at each obstacle rather than carried, a
+research source stops paying out once it's spent, and every one of those moves
+can be undone.
+
+Single self-contained `dist/index.html` — no framework, no build step to *use*
+it, nothing sent anywhere. Open it from a file, host it, or install it as an app.
+
+## The five modes
+
+| Mode | Tracks | The thing it gets right |
+|------|--------|-------------------------|
+| **Chase** | Chase Points | Excess points are discarded at each obstacle, not carried to the next |
+| **Infiltration** | Infiltration + Awareness | A failure costs 0 IP **and** hands over 1 AP; every round adds another |
+| **Influence** | Influence Points | Which of the NPC's resistances and weaknesses the party has actually Discovered |
+| **Research** | Research Points | Each source has a maximum, after which it gives nothing |
+| **Victory Points** | whatever you name them | Accumulating and diminishing scales, seeded from GM Core's own table |
+
+The fifth is the escape hatch. Reputation, duels, leadership and hexploration
+ship as reference text rather than runners — name your own points, set your own
+thresholds, and the same board runs them.
+
+### At the table
+
+- **One tap per PC per round.** Four buttons, one per degree of success, and the
+  app works out what moves.
+- **Undo.** Every action is reversible, including across an obstacle boundary
+  where points were discarded and no arithmetic could put them back.
+- **42 sample obstacles.** GM Core's Underground, Urban and Wilderness chase
+  tables, with their real skills and DCs, pickable when you're building a chase.
+- **Prep and run are separate.** Resetting a run hands the prepped chase back
+  untouched; an export code carries the prep and none of last week's dice.
+- **Where the book says "the GM decides", the app asks.** Obstacle costs, the
+  awareness failure point, round lengths and thresholds are prefilled with the
+  book's rule of thumb and left editable.
+
+## Run it
+
+```sh
+python3 tools/build.py        # assemble dist/index.html
+# then either:
+open dist/index.html          # straight from the file, fully offline
+npx pf2e-subsystems           # serve at http://localhost:8727 and open the browser
+```
+
+## Where the rules text comes from
+
+Every word of quoted rules text is Paizo's own, generated from the open-source
+Foundry VTT pf2e data so it can't drift from the book. The subsystems chapter
+lives in the GM Screen journal; the conditions and actions come from their own
+packs. The subsystem pages are on the `v14-dev` branch:
+
+```sh
+git clone --depth 1 --filter=blob:none --sparse -b v14-dev \
+    https://github.com/foundryvtt/pf2e.git pf2e-data
+cd pf2e-data && git sparse-checkout set packs/pf2e/journals \
+    packs/pf2e/conditions packs/pf2e/actions && cd ..
+
+python3 tools/build_subsystems.py \
+    --src pf2e-data/packs/pf2e/journals/gm-screen.json \
+    --out data/subsystems.generated.js
+python3 tools/build_reference.py --src pf2e-data/packs/pf2e \
+    --out data/reference.generated.js
+python3 tools/build.py
+```
+
+The Influence page in particular is *only* a pointer to the **Influence** and
+**Discover** actions — which is why `build_reference.py` here pulls
+`actions/subsystems/` as well as the four folders the other tools use. Without
+it that page renders as two bare headings. The test suite asserts that every
+action the rules text names actually resolves.
+
+The explanations *around* that text, the run board, and every judgement about
+what to enforce and what to ask are ours.
+
+## Tests
+
+```sh
+npm install                   # jsdom
+node tools/test.mjs
+```
+
+107 assertions over the built file. They cover the arithmetic rather than the
+rendering: every degree-of-success scale, the chase discard at an obstacle
+boundary, awareness accruing at end of round, the 2× failure threshold and its
+quarter marks, individual versus group obstacles, Edge Point spends, research
+caps, thresholds firing exactly once against the right count, both Victory
+Point scales, undo restoring exactly across an obstacle advance, and that the
+two generated data files line up with each other.
+
+## The other three tools
+
+- [PF2e Primer](https://thewhytewolf.github.io/pf2eprimer/) — an interactive introduction for new players.
+- [PF2e Spellbook](https://thewhytewolf.github.io/pf2espellcards/) — player-side spell preparation and casting.
+- [PF2e Party Tracker](https://thewhytewolf.github.io/pf2epartytracker/) — GM-side passive stats, secret checks and the exploration board.
+
+## Licensing
+
+Application code is MIT (see [`LICENSE`](./LICENSE)). Bundled Pathfinder
+subsystem, condition and action text is Paizo content under the ORC and OGL
+licenses — see [`notice.md`](./notice.md). This is an unofficial fan tool, not
+affiliated with Paizo.

package/bin/cli.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+// Serves the built subsystems app from dist/ on localhost and opens the browser.
+// The port is fixed by default: localStorage (your prepped encounters) is
+// keyed by origin, so a stable http://localhost:8727 keeps your encounters
+// across package updates. localhost is a secure context, so the service
+// worker and the "Install app" button work too. (8727, one above the
+// primer's 8726, the party tracker's 8725 and the spellbook's 8724, so the
+// four apps never share an origin.)
+import http from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+
+const DEFAULT_PORT = 8727;
+
+const args = process.argv.slice(2);
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`Usage: pf2e-subsystems [--port N] [--no-open]
+
+Serves the PF2e Subsystems at http://localhost:${DEFAULT_PORT} and opens your browser.
+
+  --port N    listen on port N instead of ${DEFAULT_PORT}
+  --no-open   don't open the browser, just serve`);
+  process.exit(0);
+}
+const portIdx = args.indexOf('--port');
+const port = portIdx !== -1 ? Number(args[portIdx + 1]) : DEFAULT_PORT;
+if (!Number.isInteger(port) || port < 1 || port > 65535) {
+  console.error(`pf2e-subsystems: invalid --port ${args[portIdx + 1]}`);
+  process.exit(1);
+}
+const noOpen = args.includes('--no-open');
+
+const distDir = new URL('../dist/', import.meta.url);
+const FILES = {
+  '/': ['index.html', 'text/html; charset=utf-8'],
+  '/index.html': ['index.html', 'text/html; charset=utf-8'],
+  '/sw.js': ['sw.js', 'text/javascript; charset=utf-8'],
+  '/manifest.webmanifest': ['manifest.webmanifest', 'application/manifest+json'],
+  '/icon.svg': ['icon.svg', 'image/svg+xml'],
+};
+
+const server = http.createServer(async (req, res) => {
+  const entry = FILES[new URL(req.url, 'http://localhost').pathname];
+  if (!entry || (req.method !== 'GET' && req.method !== 'HEAD')) {
+    res.writeHead(404, { 'Content-Type': 'text/plain' }).end('Not found');
+    return;
+  }
+  const [file, type] = entry;
+  try {
+    const body = await readFile(new URL(file, distDir));
+    // no-cache so package updates (new sw.js/index.html) are picked up on reload
+    res.writeHead(200, {
+      'Content-Type': type,
+      'Content-Length': body.byteLength,
+      'Cache-Control': 'no-cache',
+    });
+    res.end(req.method === 'HEAD' ? undefined : body);
+  } catch {
+    res.writeHead(500, { 'Content-Type': 'text/plain' }).end('Read error');
+  }
+});
+
+function openBrowser(url) {
+  const [cmd, cmdArgs] =
+    process.platform === 'darwin' ? ['open', [url]]
+    : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', url]]
+    : ['xdg-open', [url]];
+  spawn(cmd, cmdArgs, { stdio: 'ignore', detached: true }).on('error', () => {
+    console.error(`Couldn't open a browser — go to ${url}`);
+  }).unref();
+}
+
+const url = `http://localhost:${port}/`;
+server.on('error', (err) => {
+  if (err.code === 'EADDRINUSE') {
+    console.log(`Port ${port} is in use — assuming the subsystems app is already running at ${url}`);
+    if (!noOpen) openBrowser(url);
+    process.exit(0);
+  }
+  console.error(`pf2e-subsystems: ${err.message}`);
+  process.exit(1);
+});
+server.listen(port, '127.0.0.1', () => {
+  console.log(`PF2e Subsystems running at ${url}  (Ctrl+C to stop)`);
+  if (!noOpen) openBrowser(url);
+});