aureate 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,48 @@
-# Temporary Holding Version
+# AUREATE
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An offline terminal puzzle game.
+
+You inherit an ORISON-4 terminal and one local note from its former owner. Somewhere inside the machine is an unfinished operation named AUREATE.
+
+## Play
+
+Run without permanent installation:
+
+```sh
+npx aureate
+```
+
+Or install the command globally:
+
+```sh
+npm install --global aureate
+aureate
+```
+
+Start a new session:
+
+```sh
+aureate --new
+```
+
+Run without loading or writing a save:
+
+```sh
+aureate --new --no-save
+```
+
+Disable animation and terminal control sequences:
+
+```sh
+aureate --no-animation
+```
+
+Use a specific save file:
+
+```sh
+aureate --save ./save.json
+```
+
+Input is case-insensitive. `SAVE` and `QUIT` are process controls. The machine has no help or hint system.
+
+AUREATE does not access the network during play and has no runtime package dependencies.

package/bin/aureate.cjs

@@ -0,0 +1,661 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli/adapter.js
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_readline = __toESM(require("node:readline"), 1);
+
+// src/core/game.js
+var ROOMS = {
+  desk: ["WELCOME", "BRASS-PLATE"],
+  drum: ["ADDRESS-TRACE", "FOLIO-A", "FOLIO-B", "CONTEXT-LEDGER"],
+  lens: ["APERTURE", "SERVICE-SLIP", "GLASS-A", "GLASS-B"],
+  patch: ["FLOW-TRACE", "CHANNEL-AMBER", "DRY-CHANNEL"],
+  bench: ["AUREATE-PLATE", "CROSSPOINT", "AMBER-JACK", "LEGACY-JACK", "SCRIPT-STORE"]
+};
+var TEXT = {
+  "desk/welcome": `ELIAS VALE / LAST LOCAL ENTRY
+
+To whoever received this machine:
+
+I left AUREATE unfinished under /BENCH/AUREATE-PLATE. It opens the note I
+could not leave on this card. No single page carries the route, but ORISON
+still does.
+
+Survey what remains before you move anything. The brass battery was new when
+I closed the case.
+
+-- E.V.`,
+  "desk/brass-plate": `BELLWETHER LOGIC TERMINAL / ORISON-4 / 1978
+LOCAL STORE 4096 W
+LINE INTERFACE: NOT FITTED
+
+OWNER RESIDUE 14-9-92
+
+    DESK> SURVEY
+    DESK> TRAVERSE /DRUM
+    DRUM> SURVEY`,
+  "desk/mark": `DESK MARK
+CALLER != DESK
+ADDRESS /DESK/MARK`,
+  "drum/address-trace": `ADDRESS TRACE 6C
+
+    DRUM> UNSEAL FOLIO-A
+    SOURCE DRUM/FOLIO-A
+
+    DRUM> UNSEAL /DESK/MARK
+    SOURCE DESK/MARK
+    CALLER DRUM`,
+  "drum/folio-a": `SERVICE MARGIN / 12-2-91
+
+FINAL OPERATION: AUR---
+REMAINDER: GLASS-A + GLASS-B
+ANCHOR: /LENS`,
+  "drum/folio-b": `DOUBLE EXPOSURE
+
+//// 0 1 0 //// AMB //// 1 1 0 ////
+VISIBLE != CARRIER
+OPTICAL PLANE: PRESENT`,
+  "drum/context-ledger": `LOCAL CONTEXT LEDGER
+
+/DESK
+/DRUM
+/LENS
+/PATCH      CONTINUITY 0
+/BENCH
+
+EXTERNAL CONTEXT: NONE`,
+  "lens/aperture": `APERTURE / FIXED OPTICAL CONSOLE
+ANCHOR /LENS
+STATE COLD`,
+  "lens/service-slip": `APERTURE SERVICE RESIDUE
+
+    LENS> INVOKE APERTURE
+    APERTURE> FOCUS GLASS-A
+    APERTURE> SUPERPOSE GLASS-A :: GLASS-B
+    APERTURE> WITHDRAW`,
+  "lens/glass-a": `GLASS-A
+VISIBLE CLEAR
+LATENT YES`,
+  "lens/glass-b": `GLASS-B
+VISIBLE SMOKED
+LATENT YES`,
+  "patch/flow-trace": `LOCAL FLOW TRACE
+
+    DRAW <SOURCE> | APERTURE{FOCUS} | DELIVER <SINK>
+
+CALIBRATION
+    SOURCE /PATCH/DRY-CHANNEL
+    FILTER APERTURE{FOCUS}
+    SINK /PATCH/CHANNEL-AMBER`,
+  "patch/channel-amber": `CHANNEL-AMBER
+LOCAL CONTINUITY 1
+EXTERNAL CONTINUITY 0`,
+  "patch/dry-channel": `DRY-CHANNEL
+INPUT 0
+LATENT 0
+WIRE NONE`
+};
+var LATENT = {
+  "desk/welcome": `OWNER MARK
+ORIGIN /DESK/WELCOME
+VOICE FIRST`,
+  "drum/folio-b": `CARRIER AMBER
+SOURCE /DRUM/FOLIO-B
+SINK /BENCH/AMBER-JACK
+PLANE LATENT`,
+  "lens/glass-a": "AURE",
+  "lens/glass-b": "ATE"
+};
+var TESTAMENT = `TESTAMENT / ELIAS VALE / LOCAL COPY
+
+ORISON began at Bellwether Works in 1978. It counted parts, opened test bays,
+and printed faults on a ribbon that stained every hand in the room.
+
+When Bellwether closed, ORISON was scrap. I took it home in the passenger seat
+of my van. Its casing was too heavy for one man, even then. Over the years I
+replaced the drum with a small local store, rebuilt the optical reader, and
+wired the dead test channels back through the desk. It has never been on a
+network. Everything you saw was here when you opened the case.
+
+AUREATE was the last thing I wrote. Paper goes damp in this house. Magnetic
+store forgets. I trusted neither with the whole account, so I left the account
+inside the route by which it is reached.
+
+If these words are on the glass, the battery held and the old relays moved one
+more time. That is enough.
+
+Keep the machine if you have room. If not, save the brass plate. My hands wore
+the corner smooth.
+
+-- Elias Vale
+
+[ AUREATE ]`;
+var ENDING_STATUS = `LOCAL STORE  HELD
+OPTICAL      COLD
+AUREATE      COMPLETE
+ORISON-4     AT REST`;
+function objectKey(target) {
+  return `${target.room}/${target.object}`;
+}
+var Game = class {
+  constructor(data = {}) {
+    const state = data.version === 2 ? data : {};
+    this.room = ROOMS[state.room] ? state.room : "desk";
+    this.mode = "shell";
+    this.flags = new Set(state.flags || []);
+    this.scripts = { ...state.scripts || {} };
+    this.visited = new Set((state.visited || ["desk"]).filter((room) => ROOMS[room]));
+    if (!this.visited.size) this.visited.add("desk");
+    this.finished = Boolean(state.finished);
+  }
+  toJSON() {
+    return {
+      version: 2,
+      room: this.room,
+      flags: [...this.flags].sort(),
+      scripts: this.scripts,
+      visited: [...this.visited].sort(),
+      finished: this.finished
+    };
+  }
+  opening() {
+    return `ORISON-4 / 1978
+LOCAL STORE  OK
+OPTICAL     COLD
+LINE        --
+
+AUTO> UNSEAL /DESK/WELCOME
+
+${TEXT["desk/welcome"]}`;
+  }
+  get prompt() {
+    return this.mode === "aperture" ? "APERTURE> " : `${this.room.toUpperCase()}> `;
+  }
+  process(input, options = {}) {
+    const line = input.trim();
+    if (!line) return { text: "", quit: false };
+    const upper = line.toUpperCase();
+    if (upper === "QUIT") return { text: "LOCAL STORE HELD", quit: true };
+    if (upper === "SAVE") return { text: "SAVE REQUESTED", quit: false };
+    if (upper === "HELP" || upper === "HINT" || upper === "RECALL") {
+      return { text: "NO SUCH LOCAL FILE", quit: false };
+    }
+    if (this.finished) return { text: TESTAMENT, quit: false };
+    if (this.mode === "aperture") return { text: this.aperture(line), quit: false };
+    if (line.includes("|") && !upper.startsWith("INSCRIBE ")) {
+      return { text: this.pipeline(line, options), quit: false };
+    }
+    const firstSpace = line.search(/\s/);
+    const command = (firstSpace < 0 ? line : line.slice(0, firstSpace)).toUpperCase();
+    const argument = firstSpace < 0 ? "" : line.slice(firstSpace).trim();
+    let text;
+    switch (command) {
+      case "SURVEY":
+        text = this.survey(argument);
+        break;
+      case "UNSEAL":
+        text = this.unseal(argument);
+        break;
+      case "TRAVERSE":
+        text = this.traverse(argument);
+        break;
+      case "INVOKE":
+        text = this.invoke(argument);
+        break;
+      case "DRAW": {
+        const drawn = this.draw(argument);
+        text = drawn.error || `STREAM ${this.pathOf(drawn.stream.source)}
+PLANE VISIBLE
+SINK --`;
+        break;
+      }
+      case "DELIVER":
+        text = "DELIVER: INPUT 0";
+        break;
+      case "INSCRIBE":
+        text = this.inscribe(line);
+        break;
+      case "PERFORM":
+        text = this.perform(argument);
+        break;
+      case "AUREATE":
+        text = this.aureate(line);
+        break;
+      default:
+        text = `? ${line.split(/\s+/)[0]}`;
+    }
+    return { text, quit: false };
+  }
+  accessibleRooms() {
+    const result = ["desk", "drum", "bench"];
+    if (this.visited.has("drum") || this.visited.has("lens")) result.push("lens");
+    if (this.flags.has("patch_open") || this.visited.has("patch")) result.push("patch");
+    return result;
+  }
+  survey(argument = "") {
+    let room = this.room;
+    if (argument) {
+      room = argument.replace(/^\/+|\/+$/g, "").toLowerCase();
+      if (!ROOMS[room] || !this.accessibleRooms().includes(room) && room !== this.room) return `? /${room.toUpperCase()}`;
+    }
+    const lines = [`/${room.toUpperCase()}`];
+    for (const object of ROOMS[room]) {
+      let mark = "";
+      if (room === "bench") {
+        const flag = { CROSSPOINT: "crosspoint", "AMBER-JACK": "amber", "LEGACY-JACK": "legacy" }[object];
+        if (flag) mark = this.flags.has(flag) ? " *" : " .";
+      }
+      lines.push(`${object}${mark}`);
+    }
+    lines.push("::");
+    for (const available of this.accessibleRooms()) lines.push(`/${available.toUpperCase()}`);
+    if (room === "drum" && !this.flags.has("patch_open")) lines.push("/PATCH !");
+    return lines.join("\n");
+  }
+  resolve(token) {
+    token = token.trim().replaceAll("\\", "/");
+    if (!token) return { error: "? ADDRESS" };
+    let room;
+    let object;
+    if (token.startsWith("/")) {
+      const parts = token.split("/").filter(Boolean);
+      if (parts.length !== 2) return { error: "? ADDRESS" };
+      room = parts[0].toLowerCase();
+      object = parts[1].toLowerCase().replaceAll("_", "-");
+    } else {
+      room = this.room;
+      object = token.toLowerCase().replaceAll("_", "-");
+    }
+    const key = `${room}/${object}`;
+    const liveBench = room === "bench" && ["aureate-plate", "crosspoint", "amber-jack", "legacy-jack", "script-store"].includes(object);
+    if (!(key in TEXT) && !liveBench) return { error: `? ${token}` };
+    return { target: { room, object } };
+  }
+  pathOf(target) {
+    return `/${target.room.toUpperCase()}/${target.object.toUpperCase()}`;
+  }
+  unseal(token) {
+    const found = this.resolve(token);
+    if (found.error) return found.error;
+    const target = found.target;
+    const key = objectKey(target);
+    if (key === "desk/mark" && this.room === "bench") {
+      this.flags.add("crosspoint");
+      return `${TEXT[key]}
+
+CROSSPOINT *
+IMPRINT
+    INVOKE APERTURE
+    ANCHOR /LENS`;
+    }
+    if (target.room === "bench") return this.benchObject(target.object);
+    return TEXT[key];
+  }
+  benchObject(object) {
+    if (object === "aureate-plate") {
+      if (this.flags.has("legacy")) {
+        return `AUREATE-PLATE
+
+AUREATE [LEGACY] :: @/DESK/WELCOME >> TESTAMENT`;
+      }
+      return `AUREATE-PLATE
+
+??????? [??????] :: @????????????? >> TESTAMENT`;
+    }
+    if (object === "crosspoint") {
+      if (this.flags.has("crosspoint")) return "CROSSPOINT *\nCALLER /BENCH\nSOURCE /DESK/MARK";
+      return `CROSSPOINT .
+CALLER /BENCH
+SOURCE /DESK/MARK
+TRAVERSE 0`;
+    }
+    if (object === "amber-jack") {
+      if (this.flags.has("amber")) return "AMBER-JACK *\nCARRIER AMBER\nPLANE LATENT";
+      return `AMBER-JACK .
+SOURCE /DRUM/FOLIO-B
+PLANE LATENT
+CARRIER AMBER`;
+    }
+    if (object === "legacy-jack") {
+      if (this.flags.has("legacy")) return "LEGACY-JACK *\nNAME LEGACY\nORIGIN /DESK/WELCOME";
+      return `LEGACY-JACK .
+NAME LEGACY
+SOURCE /DESK/WELCOME
+PLANE LATENT
+SINK /BENCH/LEGACY-JACK`;
+    }
+    if (object === "script-store") {
+      if (!this.flags.has("amber")) return "SCRIPT-STORE\nSTATE COLD";
+      return `SCRIPT-STORE
+STATE HELD
+
+INSCRIBE <NAME> := <LINE>
+PERFORM <NAME>`;
+    }
+    return "?";
+  }
+  traverse(token) {
+    if (!token) return "? CONTEXT";
+    const room = token.replace(/^\/+|\/+$/g, "").toLowerCase();
+    if (!ROOMS[room]) return `? /${room.toUpperCase()}`;
+    this.room = room;
+    this.mode = "shell";
+    this.visited.add(room);
+    return this.survey();
+  }
+  invoke(token) {
+    if (token.trim().toLowerCase() !== "aperture") return `? ${token || "TOOL"}`;
+    if (this.room !== "lens") return "APERTURE ANCHOR /LENS";
+    this.mode = "aperture";
+    return `APERTURE
+ANCHOR /LENS
+
+> FOCUS GLASS-A
+> SUPERPOSE GLASS-A :: GLASS-B
+> WITHDRAW`;
+  }
+  aperture(line) {
+    const upper = line.toUpperCase();
+    if (upper === "WITHDRAW") {
+      this.mode = "shell";
+      return "/LENS";
+    }
+    if (upper.startsWith("FOCUS ")) {
+      const found = this.resolve(line.slice(line.search(/\s/) + 1));
+      if (found.error) return found.error;
+      const key = objectKey(found.target);
+      if (!(key in LATENT)) return `${this.pathOf(found.target)}
+LATENT 0`;
+      return `${this.pathOf(found.target)}
+LATENT 1
+
+${LATENT[key]}`;
+    }
+    if (upper.startsWith("SUPERPOSE ")) {
+      const parts = line.slice(line.search(/\s/) + 1).split("::");
+      if (parts.length !== 2) return "SUPERPOSE ? :: ?";
+      const left = this.resolve(parts[0].trim());
+      const right = this.resolve(parts[1].trim());
+      if (left.error) return left.error;
+      if (right.error) return right.error;
+      const pair = /* @__PURE__ */ new Set([objectKey(left.target), objectKey(right.target)]);
+      if (pair.size === 2 && pair.has("lens/glass-a") && pair.has("lens/glass-b")) {
+        this.flags.add("patch_open");
+        return `AURE + ATE
+AUREATE
+
+/PATCH CONTINUITY 1`;
+      }
+      return "REGISTRATION 0";
+    }
+    return `? ${line.split(/\s+/)[0]}`;
+  }
+  draw(token) {
+    const found = this.resolve(token);
+    if (found.error) return { error: found.error };
+    const target = found.target;
+    const text = target.room === "bench" ? this.benchObject(target.object) : TEXT[objectKey(target)];
+    return { stream: { source: target, plane: "visible", text } };
+  }
+  pipeline(line, options = {}) {
+    const parts = line.split("|").map((part) => part.trim());
+    if (parts.some((part) => !part) || !/^DRAW\s+/i.test(parts[0])) return "FLOW 0";
+    const drawn = this.draw(parts[0].replace(/^DRAW\s+/i, ""));
+    if (drawn.error) return drawn.error;
+    let stream = drawn.stream;
+    const result = [`DRAW ${this.pathOf(stream.source)}`];
+    let delivered = false;
+    for (const part of parts.slice(1)) {
+      if (/^APERTURE\{FOCUS\}$/i.test(part)) {
+        const key = objectKey(stream.source);
+        if (!(key in LATENT)) return "APERTURE{FOCUS} LATENT 0";
+        stream = { source: stream.source, plane: "latent", text: LATENT[key] };
+        result.push("APERTURE{FOCUS} LATENT 1");
+      } else if (/^DELIVER\s+/i.test(part)) {
+        if (delivered) return "SINK HELD";
+        const found = this.resolve(part.replace(/^DELIVER\s+/i, ""));
+        if (found.error) return found.error;
+        result.push(this.deliver(stream, found.target, options));
+        delivered = true;
+      } else {
+        return `? ${part}`;
+      }
+    }
+    if (!delivered) result.push("", stream.text);
+    return result.join("\n");
+  }
+  deliver(stream, target, options = {}) {
+    const destination = objectKey(target);
+    if (destination === "bench/amber-jack") {
+      if (objectKey(stream.source) !== "drum/folio-b" || stream.plane !== "latent") return "AMBER-JACK REJECT";
+      this.flags.add("amber");
+      return `DELIVER /BENCH/AMBER-JACK
+AMBER-JACK *
+
+SCRIPT-STORE HELD
+INSCRIBE <NAME> := <LINE>
+PERFORM <NAME>`;
+    }
+    if (destination === "bench/legacy-jack") {
+      if (objectKey(stream.source) !== "desk/welcome" || stream.plane !== "latent") return "LEGACY-JACK REJECT";
+      if (!options.scripted || String(options.scriptName).toUpperCase() !== "LEGACY") return "LEGACY-JACK NAME ?";
+      this.flags.add("legacy");
+      return `DELIVER /BENCH/LEGACY-JACK
+LEGACY-JACK *
+ORIGIN /DESK/WELCOME
+AUREATE-PLATE HELD`;
+    }
+    return `${this.pathOf(target)} SINK 0`;
+  }
+  inscribe(line) {
+    if (this.room !== "bench") return "SCRIPT-STORE ANCHOR /BENCH";
+    const match = line.match(/^INSCRIBE\s+([A-Z0-9_-]+)\s*:=\s*(.+)$/is);
+    if (!match) return "INSCRIBE ? := ?";
+    const name = match[1].toUpperCase();
+    const body = match[2].trim();
+    const head = body.split(/\s+/, 1)[0].toUpperCase();
+    if (["INSCRIBE", "PERFORM", "AUREATE"].includes(head) || body.length > 300) return "SCRIPT-STORE REJECT";
+    this.scripts[name] = body;
+    return `${name} := ${body}`;
+  }
+  perform(token) {
+    if (this.room !== "bench") return "SCRIPT-STORE ANCHOR /BENCH";
+    const name = token.trim().toUpperCase();
+    if (!(name in this.scripts)) return `${name || "?"} : --`;
+    const output = this.process(this.scripts[name], { scripted: true, scriptName: name });
+    return `${name}
+${output.text}`;
+  }
+  aureate(line) {
+    const match = line.match(/^AUREATE\s+\[([A-Z0-9_-]+)\]\s*::\s*@([^\s]+)\s*>>\s*TESTAMENT$/i);
+    if (!match) return "AUREATE [??????] :: @????????????? >> TESTAMENT";
+    if (this.room !== "bench") return "AUREATE CONTEXT ?";
+    const script = match[1].toUpperCase();
+    const origin = this.resolve(match[2]);
+    if (script !== "LEGACY") return "LEGACY --";
+    if (origin.error || objectKey(origin.target) !== "desk/welcome") return "ORIGIN ?";
+    this.finished = true;
+    this.flags.add("aureate");
+    return TESTAMENT;
+  }
+};
+
+// src/cli/adapter.js
+var wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+async function writeSlow(text, milliseconds = 12) {
+  for (const character of text) {
+    process.stdout.write(character);
+    if (character !== " " && character !== "\n") await wait(milliseconds);
+  }
+}
+async function writeLines(text, milliseconds = 24) {
+  const lines = text.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    process.stdout.write(lines[index]);
+    if (index < lines.length - 1) process.stdout.write("\n");
+    await wait(milliseconds);
+  }
+}
+function clearTerminal() {
+  process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+}
+async function boot(game, restored, animated) {
+  if (!animated) {
+    if (!restored) console.log(game.opening());
+    else if (game.finished) console.log("ORISON-4 / 1978\nLOCAL STORE  HELD");
+    else console.log(`ORISON-4 / 1978
+LOCAL STORE  HELD
+
+${game.survey()}`);
+    return;
+  }
+  clearTerminal();
+  process.stdout.write("\x1B[?25l");
+  await writeSlow("ORISON-4 / 1978", 24);
+  process.stdout.write("\n\nLOCAL STORE  0000 W");
+  for (const amount of ["1024", "2048", "3072", "4096"]) {
+    await wait(110);
+    process.stdout.write(`\rLOCAL STORE  ${amount} W`);
+  }
+  await wait(140);
+  process.stdout.write("  OK\nOPTICAL      COLD\nLINE         --\n");
+  await wait(260);
+  if (restored) {
+    process.stdout.write("\nSTORE> HELD");
+    if (!game.finished) {
+      process.stdout.write("\n\n");
+      await writeLines(game.survey(), 16);
+    }
+  } else {
+    const opening = game.opening().split("\n");
+    const autoIndex = opening.findIndex((line) => line.startsWith("AUTO>"));
+    process.stdout.write("\n");
+    await writeSlow(opening[autoIndex], 18);
+    process.stdout.write("\n\n");
+    await writeLines(opening.slice(autoIndex + 2).join("\n"), 22);
+  }
+  process.stdout.write("\x1B[?25h");
+}
+async function settleTerminal(animated) {
+  if (animated) {
+    await wait(420);
+    process.stdout.write("\n\n\x1B[?25l");
+    await writeLines(ENDING_STATUS, 180);
+    process.stdout.write("\n\x1B[?25h");
+  } else {
+    console.log(`
+${ENDING_STATUS}`);
+  }
+}
+function defaultSavePath() {
+  if (process.platform === "win32") {
+    const root2 = process.env.APPDATA || import_node_path.default.join(import_node_os.default.homedir(), "AppData", "Roaming");
+    return import_node_path.default.join(root2, "AUREATE", "save.json");
+  }
+  const root = process.env.XDG_DATA_HOME || import_node_path.default.join(import_node_os.default.homedir(), ".local", "share");
+  return import_node_path.default.join(root, "aureate", "save.json");
+}
+function loadGame(savePath) {
+  try {
+    return new Game(JSON.parse(import_node_fs.default.readFileSync(savePath, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function saveGame(game, savePath) {
+  import_node_fs.default.mkdirSync(import_node_path.default.dirname(savePath), { recursive: true });
+  import_node_fs.default.writeFileSync(savePath, `${JSON.stringify(game.toJSON(), null, 2)}
+`, "utf8");
+}
+function parseArgs(args) {
+  const options = { fresh: false, noSave: false, noAnimation: false, savePath: defaultSavePath() };
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === "--new") options.fresh = true;
+    else if (args[index] === "--no-save") options.noSave = true;
+    else if (args[index] === "--no-animation") options.noAnimation = true;
+    else if (args[index] === "--save" && args[index + 1]) options.savePath = import_node_path.default.resolve(args[++index]);
+    else if (args[index] === "--help") {
+      console.log("AUREATE [--new] [--no-save] [--no-animation] [--save FILE]");
+      return null;
+    }
+  }
+  return options;
+}
+async function run(args = process.argv.slice(2)) {
+  const options = parseArgs(args);
+  if (!options) return;
+  let game = null;
+  if (!options.fresh && !options.noSave && import_node_fs.default.existsSync(options.savePath)) game = loadGame(options.savePath);
+  const restored = Boolean(game);
+  if (!game) game = new Game();
+  const animated = Boolean(process.stdin.isTTY && process.stdout.isTTY && !options.noAnimation);
+  if (animated) process.once("exit", () => process.stdout.write("\x1B[?25h"));
+  await boot(game, restored, animated);
+  if (game.finished) {
+    await settleTerminal(animated);
+    return;
+  }
+  const terminal = import_node_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: Boolean(process.stdin.isTTY)
+  });
+  terminal.setPrompt(`
+${game.prompt}`);
+  terminal.prompt();
+  for await (const line of terminal) {
+    const output = game.process(line);
+    if (output.text === "SAVE REQUESTED") {
+      if (!options.noSave) saveGame(game, options.savePath);
+      console.log(options.noSave ? "LOCAL STORE INHIBITED" : "LOCAL STORE HELD");
+    } else {
+      if (output.text === TESTAMENT && animated) {
+        process.stdout.write("\n");
+        await writeLines(output.text, 30);
+        process.stdout.write("\n");
+      } else if (output.text) {
+        console.log(output.text);
+      }
+      if (!options.noSave) saveGame(game, options.savePath);
+      if (game.finished) {
+        await settleTerminal(animated);
+        break;
+      }
+      if (output.quit) break;
+    }
+    terminal.setPrompt(`
+${game.prompt}`);
+    terminal.prompt();
+  }
+  terminal.close();
+}
+
+// src/cli/main.js
+run().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "aureate",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "An offline terminal puzzle game about discovering a missing command.",
+  "bin": {
+    "aureate": "bin/aureate.cjs"
+  },
+  "files": [
+    "bin",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "game",
+    "terminal",
+    "cli",
+    "puzzle",
+    "interactive-fiction"
+  ],
+  "license": "UNLICENSED"
+}