silver-tongue 0.1.0

package/dist/silver-tongue.mjs

@@ -0,0 +1,1871 @@
+#!/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 __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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
+));
+
+// ../../node_modules/@fluent/bundle/index.js
+var require_bundle = __commonJS({
+  "../../node_modules/@fluent/bundle/index.js"(exports, module) {
+    (function(global, factory) {
+      typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define("@fluent/bundle", ["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.FluentBundle = {}));
+    })(exports, (function(exports2) {
+      "use strict";
+      class FluentType {
+        /**
+         * Create a `FluentType` instance.
+         *
+         * @param value The JavaScript value to wrap.
+         */
+        constructor(value) {
+          this.value = value;
+        }
+        /**
+         * Unwrap the raw value stored by this `FluentType`.
+         */
+        valueOf() {
+          return this.value;
+        }
+      }
+      class FluentNone extends FluentType {
+        /**
+         * Create an instance of `FluentNone` with an optional fallback value.
+         * @param value The fallback value of this `FluentNone`.
+         */
+        constructor(value = "???") {
+          super(value);
+        }
+        /**
+         * Format this `FluentNone` to the fallback string.
+         */
+        toString(scope) {
+          return `{${this.value}}`;
+        }
+      }
+      class FluentNumber extends FluentType {
+        /**
+         * Create an instance of `FluentNumber` with options to the
+         * `Intl.NumberFormat` constructor.
+         *
+         * @param value The number value of this `FluentNumber`.
+         * @param opts Options which will be passed to `Intl.NumberFormat`.
+         */
+        constructor(value, opts = {}) {
+          super(value);
+          this.opts = opts;
+        }
+        /**
+         * Format this `FluentNumber` to a string.
+         */
+        toString(scope) {
+          try {
+            const nf = scope.memoizeIntlObject(Intl.NumberFormat, this.opts);
+            return nf.format(this.value);
+          } catch (err) {
+            scope.reportError(err);
+            return this.value.toString(10);
+          }
+        }
+      }
+      class FluentDateTime extends FluentType {
+        /**
+         * Create an instance of `FluentDateTime` with options to the
+         * `Intl.DateTimeFormat` constructor.
+         *
+         * @param value The number value of this `FluentDateTime`, in milliseconds.
+         * @param opts Options which will be passed to `Intl.DateTimeFormat`.
+         */
+        constructor(value, opts = {}) {
+          super(value);
+          this.opts = opts;
+        }
+        /**
+         * Format this `FluentDateTime` to a string.
+         */
+        toString(scope) {
+          try {
+            const dtf = scope.memoizeIntlObject(Intl.DateTimeFormat, this.opts);
+            return dtf.format(this.value);
+          } catch (err) {
+            scope.reportError(err);
+            return new Date(this.value).toISOString();
+          }
+        }
+      }
+      const MAX_PLACEABLES = 100;
+      const FSI = "\u2068";
+      const PDI = "\u2069";
+      function match(scope, selector, key) {
+        if (key === selector) {
+          return true;
+        }
+        if (key instanceof FluentNumber && selector instanceof FluentNumber && key.value === selector.value) {
+          return true;
+        }
+        if (selector instanceof FluentNumber && typeof key === "string") {
+          let category = scope.memoizeIntlObject(Intl.PluralRules, selector.opts).select(selector.value);
+          if (key === category) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function getDefault(scope, variants, star) {
+        if (variants[star]) {
+          return resolvePattern(scope, variants[star].value);
+        }
+        scope.reportError(new RangeError("No default"));
+        return new FluentNone();
+      }
+      function getArguments(scope, args) {
+        const positional = [];
+        const named = /* @__PURE__ */ Object.create(null);
+        for (const arg of args) {
+          if (arg.type === "narg") {
+            named[arg.name] = resolveExpression(scope, arg.value);
+          } else {
+            positional.push(resolveExpression(scope, arg));
+          }
+        }
+        return { positional, named };
+      }
+      function resolveExpression(scope, expr) {
+        switch (expr.type) {
+          case "str":
+            return expr.value;
+          case "num":
+            return new FluentNumber(expr.value, {
+              minimumFractionDigits: expr.precision
+            });
+          case "var":
+            return resolveVariableReference(scope, expr);
+          case "mesg":
+            return resolveMessageReference(scope, expr);
+          case "term":
+            return resolveTermReference(scope, expr);
+          case "func":
+            return resolveFunctionReference(scope, expr);
+          case "select":
+            return resolveSelectExpression(scope, expr);
+          default:
+            return new FluentNone();
+        }
+      }
+      function resolveVariableReference(scope, { name }) {
+        let arg;
+        if (scope.params) {
+          if (Object.prototype.hasOwnProperty.call(scope.params, name)) {
+            arg = scope.params[name];
+          } else {
+            return new FluentNone(`$${name}`);
+          }
+        } else if (scope.args && Object.prototype.hasOwnProperty.call(scope.args, name)) {
+          arg = scope.args[name];
+        } else {
+          scope.reportError(new ReferenceError(`Unknown variable: $${name}`));
+          return new FluentNone(`$${name}`);
+        }
+        if (arg instanceof FluentType) {
+          return arg;
+        }
+        switch (typeof arg) {
+          case "string":
+            return arg;
+          case "number":
+            return new FluentNumber(arg);
+          case "object":
+            if (arg instanceof Date) {
+              return new FluentDateTime(arg.getTime());
+            }
+          // eslint-disable-next-line no-fallthrough
+          default:
+            scope.reportError(new TypeError(`Variable type not supported: $${name}, ${typeof arg}`));
+            return new FluentNone(`$${name}`);
+        }
+      }
+      function resolveMessageReference(scope, { name, attr }) {
+        const message = scope.bundle._messages.get(name);
+        if (!message) {
+          scope.reportError(new ReferenceError(`Unknown message: ${name}`));
+          return new FluentNone(name);
+        }
+        if (attr) {
+          const attribute = message.attributes[attr];
+          if (attribute) {
+            return resolvePattern(scope, attribute);
+          }
+          scope.reportError(new ReferenceError(`Unknown attribute: ${attr}`));
+          return new FluentNone(`${name}.${attr}`);
+        }
+        if (message.value) {
+          return resolvePattern(scope, message.value);
+        }
+        scope.reportError(new ReferenceError(`No value: ${name}`));
+        return new FluentNone(name);
+      }
+      function resolveTermReference(scope, { name, attr, args }) {
+        const id = `-${name}`;
+        const term2 = scope.bundle._terms.get(id);
+        if (!term2) {
+          scope.reportError(new ReferenceError(`Unknown term: ${id}`));
+          return new FluentNone(id);
+        }
+        if (attr) {
+          const attribute = term2.attributes[attr];
+          if (attribute) {
+            scope.params = getArguments(scope, args).named;
+            const resolved2 = resolvePattern(scope, attribute);
+            scope.params = null;
+            return resolved2;
+          }
+          scope.reportError(new ReferenceError(`Unknown attribute: ${attr}`));
+          return new FluentNone(`${id}.${attr}`);
+        }
+        scope.params = getArguments(scope, args).named;
+        const resolved = resolvePattern(scope, term2.value);
+        scope.params = null;
+        return resolved;
+      }
+      function resolveFunctionReference(scope, { name, args }) {
+        let func = scope.bundle._functions[name];
+        if (!func) {
+          scope.reportError(new ReferenceError(`Unknown function: ${name}()`));
+          return new FluentNone(`${name}()`);
+        }
+        if (typeof func !== "function") {
+          scope.reportError(new TypeError(`Function ${name}() is not callable`));
+          return new FluentNone(`${name}()`);
+        }
+        try {
+          let resolved = getArguments(scope, args);
+          return func(resolved.positional, resolved.named);
+        } catch (err) {
+          scope.reportError(err);
+          return new FluentNone(`${name}()`);
+        }
+      }
+      function resolveSelectExpression(scope, { selector, variants, star }) {
+        let sel = resolveExpression(scope, selector);
+        if (sel instanceof FluentNone) {
+          return getDefault(scope, variants, star);
+        }
+        for (const variant of variants) {
+          const key = resolveExpression(scope, variant.key);
+          if (match(scope, sel, key)) {
+            return resolvePattern(scope, variant.value);
+          }
+        }
+        return getDefault(scope, variants, star);
+      }
+      function resolveComplexPattern(scope, ptn) {
+        if (scope.dirty.has(ptn)) {
+          scope.reportError(new RangeError("Cyclic reference"));
+          return new FluentNone();
+        }
+        scope.dirty.add(ptn);
+        const result = [];
+        const useIsolating = scope.bundle._useIsolating && ptn.length > 1;
+        for (const elem of ptn) {
+          if (typeof elem === "string") {
+            result.push(scope.bundle._transform(elem));
+            continue;
+          }
+          scope.placeables++;
+          if (scope.placeables > MAX_PLACEABLES) {
+            scope.dirty.delete(ptn);
+            throw new RangeError(`Too many placeables expanded: ${scope.placeables}, max allowed is ${MAX_PLACEABLES}`);
+          }
+          if (useIsolating) {
+            result.push(FSI);
+          }
+          result.push(resolveExpression(scope, elem).toString(scope));
+          if (useIsolating) {
+            result.push(PDI);
+          }
+        }
+        scope.dirty.delete(ptn);
+        return result.join("");
+      }
+      function resolvePattern(scope, value) {
+        if (typeof value === "string") {
+          return scope.bundle._transform(value);
+        }
+        return resolveComplexPattern(scope, value);
+      }
+      class Scope {
+        constructor(bundle, errors, args) {
+          this.dirty = /* @__PURE__ */ new WeakSet();
+          this.params = null;
+          this.placeables = 0;
+          this.bundle = bundle;
+          this.errors = errors;
+          this.args = args;
+        }
+        reportError(error) {
+          if (!this.errors || !(error instanceof Error)) {
+            throw error;
+          }
+          this.errors.push(error);
+        }
+        memoizeIntlObject(ctor, opts) {
+          let cache2 = this.bundle._intls.get(ctor);
+          if (!cache2) {
+            cache2 = {};
+            this.bundle._intls.set(ctor, cache2);
+          }
+          let id = JSON.stringify(opts);
+          if (!cache2[id]) {
+            cache2[id] = new ctor(this.bundle.locales, opts);
+          }
+          return cache2[id];
+        }
+      }
+      function values(opts, allowed) {
+        const unwrapped = /* @__PURE__ */ Object.create(null);
+        for (const [name, opt] of Object.entries(opts)) {
+          if (allowed.includes(name)) {
+            unwrapped[name] = opt.valueOf();
+          }
+        }
+        return unwrapped;
+      }
+      const NUMBER_ALLOWED = [
+        "unitDisplay",
+        "currencyDisplay",
+        "useGrouping",
+        "minimumIntegerDigits",
+        "minimumFractionDigits",
+        "maximumFractionDigits",
+        "minimumSignificantDigits",
+        "maximumSignificantDigits"
+      ];
+      function NUMBER(args, opts) {
+        let arg = args[0];
+        if (arg instanceof FluentNone) {
+          return new FluentNone(`NUMBER(${arg.valueOf()})`);
+        }
+        if (arg instanceof FluentNumber) {
+          return new FluentNumber(arg.valueOf(), {
+            ...arg.opts,
+            ...values(opts, NUMBER_ALLOWED)
+          });
+        }
+        if (arg instanceof FluentDateTime) {
+          return new FluentNumber(arg.valueOf(), {
+            ...values(opts, NUMBER_ALLOWED)
+          });
+        }
+        throw new TypeError("Invalid argument to NUMBER");
+      }
+      const DATETIME_ALLOWED = [
+        "dateStyle",
+        "timeStyle",
+        "fractionalSecondDigits",
+        "dayPeriod",
+        "hour12",
+        "weekday",
+        "era",
+        "year",
+        "month",
+        "day",
+        "hour",
+        "minute",
+        "second",
+        "timeZoneName"
+      ];
+      function DATETIME(args, opts) {
+        let arg = args[0];
+        if (arg instanceof FluentNone) {
+          return new FluentNone(`DATETIME(${arg.valueOf()})`);
+        }
+        if (arg instanceof FluentDateTime) {
+          return new FluentDateTime(arg.valueOf(), {
+            ...arg.opts,
+            ...values(opts, DATETIME_ALLOWED)
+          });
+        }
+        if (arg instanceof FluentNumber) {
+          return new FluentDateTime(arg.valueOf(), {
+            ...values(opts, DATETIME_ALLOWED)
+          });
+        }
+        throw new TypeError("Invalid argument to DATETIME");
+      }
+      const cache = /* @__PURE__ */ new Map();
+      function getMemoizerForLocale(locales) {
+        const stringLocale = Array.isArray(locales) ? locales.join(" ") : locales;
+        let memoizer = cache.get(stringLocale);
+        if (memoizer === void 0) {
+          memoizer = /* @__PURE__ */ new Map();
+          cache.set(stringLocale, memoizer);
+        }
+        return memoizer;
+      }
+      class FluentBundle2 {
+        /**
+         * Create an instance of `FluentBundle`.
+         *
+         * @example
+         * ```js
+         * let bundle = new FluentBundle(["en-US", "en"]);
+         *
+         * let bundle = new FluentBundle(locales, {useIsolating: false});
+         *
+         * let bundle = new FluentBundle(locales, {
+         *   useIsolating: true,
+         *   functions: {
+         *     NODE_ENV: () => process.env.NODE_ENV
+         *   }
+         * });
+         * ```
+         *
+         * @param locales - Used to instantiate `Intl` formatters used by translations.
+         * @param options - Optional configuration for the bundle.
+         */
+        constructor(locales, { functions, useIsolating = true, transform = (v) => v } = {}) {
+          this._terms = /* @__PURE__ */ new Map();
+          this._messages = /* @__PURE__ */ new Map();
+          this.locales = Array.isArray(locales) ? locales : [locales];
+          this._functions = {
+            NUMBER,
+            DATETIME,
+            ...functions
+          };
+          this._useIsolating = useIsolating;
+          this._transform = transform;
+          this._intls = getMemoizerForLocale(locales);
+        }
+        /**
+         * Check if a message is present in the bundle.
+         *
+         * @param id - The identifier of the message to check.
+         */
+        hasMessage(id) {
+          return this._messages.has(id);
+        }
+        /**
+         * Return a raw unformatted message object from the bundle.
+         *
+         * Raw messages are `{value, attributes}` shapes containing translation units
+         * called `Patterns`. `Patterns` are implementation-specific; they should be
+         * treated as black boxes and formatted with `FluentBundle.formatPattern`.
+         *
+         * @param id - The identifier of the message to check.
+         */
+        getMessage(id) {
+          return this._messages.get(id);
+        }
+        /**
+         * Add a translation resource to the bundle.
+         *
+         * @example
+         * ```js
+         * let res = new FluentResource("foo = Foo");
+         * bundle.addResource(res);
+         * bundle.getMessage("foo");
+         * // → {value: .., attributes: {..}}
+         * ```
+         *
+         * @param res
+         * @param options
+         */
+        addResource(res, { allowOverrides = false } = {}) {
+          const errors = [];
+          for (let i = 0; i < res.body.length; i++) {
+            let entry = res.body[i];
+            if (entry.id.startsWith("-")) {
+              if (allowOverrides === false && this._terms.has(entry.id)) {
+                errors.push(new Error(`Attempt to override an existing term: "${entry.id}"`));
+                continue;
+              }
+              this._terms.set(entry.id, entry);
+            } else {
+              if (allowOverrides === false && this._messages.has(entry.id)) {
+                errors.push(new Error(`Attempt to override an existing message: "${entry.id}"`));
+                continue;
+              }
+              this._messages.set(entry.id, entry);
+            }
+          }
+          return errors;
+        }
+        /**
+         * Format a `Pattern` to a string.
+         *
+         * Format a raw `Pattern` into a string. `args` will be used to resolve
+         * references to variables passed as arguments to the translation.
+         *
+         * In case of errors `formatPattern` will try to salvage as much of the
+         * translation as possible and will still return a string. For performance
+         * reasons, the encountered errors are not returned but instead are appended
+         * to the `errors` array passed as the third argument.
+         *
+         * If `errors` is omitted, the first encountered error will be thrown.
+         *
+         * @example
+         * ```js
+         * let errors = [];
+         * bundle.addResource(
+         *     new FluentResource("hello = Hello, {$name}!"));
+         *
+         * let hello = bundle.getMessage("hello");
+         * if (hello.value) {
+         *     bundle.formatPattern(hello.value, {name: "Jane"}, errors);
+         *     // Returns "Hello, Jane!" and `errors` is empty.
+         *
+         *     bundle.formatPattern(hello.value, undefined, errors);
+         *     // Returns "Hello, {$name}!" and `errors` is now:
+         *     // [<ReferenceError: Unknown variable: name>]
+         * }
+         * ```
+         */
+        formatPattern(pattern, args = null, errors = null) {
+          if (typeof pattern === "string") {
+            return this._transform(pattern);
+          }
+          let scope = new Scope(this, errors, args);
+          try {
+            let value = resolveComplexPattern(scope, pattern);
+            return value.toString(scope);
+          } catch (err) {
+            if (scope.errors && err instanceof Error) {
+              scope.errors.push(err);
+              return new FluentNone().toString(scope);
+            }
+            throw err;
+          }
+        }
+      }
+      const RE_MESSAGE_START = /^(-?[a-zA-Z][\w-]*) *= */gm;
+      const RE_ATTRIBUTE_START = /\.([a-zA-Z][\w-]*) *= */y;
+      const RE_VARIANT_START = /\*?\[/y;
+      const RE_NUMBER_LITERAL = /(-?[0-9]+(?:\.([0-9]+))?)/y;
+      const RE_IDENTIFIER = /([a-zA-Z][\w-]*)/y;
+      const RE_REFERENCE = /([$-])?([a-zA-Z][\w-]*)(?:\.([a-zA-Z][\w-]*))?/y;
+      const RE_FUNCTION_NAME = /^[A-Z][A-Z0-9_-]*$/;
+      const RE_TEXT_RUN = /([^{}\n\r]+)/y;
+      const RE_STRING_RUN = /([^\\"\n\r]*)/y;
+      const RE_STRING_ESCAPE = /\\([\\"])/y;
+      const RE_UNICODE_ESCAPE = /\\u([a-fA-F0-9]{4})|\\U([a-fA-F0-9]{6})/y;
+      const RE_LEADING_NEWLINES = /^\n+/;
+      const RE_TRAILING_SPACES = / +$/;
+      const RE_BLANK_LINES = / *\r?\n/g;
+      const RE_INDENT = /( *)$/;
+      const TOKEN_BRACE_OPEN = /{\s*/y;
+      const TOKEN_BRACE_CLOSE = /\s*}/y;
+      const TOKEN_BRACKET_OPEN = /\[\s*/y;
+      const TOKEN_BRACKET_CLOSE = /\s*] */y;
+      const TOKEN_PAREN_OPEN = /\s*\(\s*/y;
+      const TOKEN_ARROW = /\s*->\s*/y;
+      const TOKEN_COLON = /\s*:\s*/y;
+      const TOKEN_COMMA = /\s*,?\s*/y;
+      const TOKEN_BLANK = /\s+/y;
+      class FluentResource2 {
+        constructor(source) {
+          this.body = [];
+          RE_MESSAGE_START.lastIndex = 0;
+          let cursor = 0;
+          while (true) {
+            let next = RE_MESSAGE_START.exec(source);
+            if (next === null) {
+              break;
+            }
+            cursor = RE_MESSAGE_START.lastIndex;
+            try {
+              this.body.push(parseMessage(next[1]));
+            } catch (err) {
+              if (err instanceof SyntaxError) {
+                continue;
+              }
+              throw err;
+            }
+          }
+          function test(re) {
+            re.lastIndex = cursor;
+            return re.test(source);
+          }
+          function consumeChar(char, errorClass) {
+            if (source[cursor] === char) {
+              cursor++;
+              return true;
+            }
+            if (errorClass) {
+              throw new errorClass(`Expected ${char}`);
+            }
+            return false;
+          }
+          function consumeToken(re, errorClass) {
+            if (test(re)) {
+              cursor = re.lastIndex;
+              return true;
+            }
+            if (errorClass) {
+              throw new errorClass(`Expected ${re.toString()}`);
+            }
+            return false;
+          }
+          function match2(re) {
+            re.lastIndex = cursor;
+            let result = re.exec(source);
+            if (result === null) {
+              throw new SyntaxError(`Expected ${re.toString()}`);
+            }
+            cursor = re.lastIndex;
+            return result;
+          }
+          function match1(re) {
+            return match2(re)[1];
+          }
+          function parseMessage(id) {
+            let value = parsePattern();
+            let attributes = parseAttributes();
+            if (value === null && Object.keys(attributes).length === 0) {
+              throw new SyntaxError("Expected message value or attributes");
+            }
+            return { id, value, attributes };
+          }
+          function parseAttributes() {
+            let attrs = /* @__PURE__ */ Object.create(null);
+            while (test(RE_ATTRIBUTE_START)) {
+              let name = match1(RE_ATTRIBUTE_START);
+              let value = parsePattern();
+              if (value === null) {
+                throw new SyntaxError("Expected attribute value");
+              }
+              attrs[name] = value;
+            }
+            return attrs;
+          }
+          function parsePattern() {
+            let first;
+            if (test(RE_TEXT_RUN)) {
+              first = match1(RE_TEXT_RUN);
+            }
+            if (source[cursor] === "{" || source[cursor] === "}") {
+              return parsePatternElements(first ? [first] : [], Infinity);
+            }
+            let indent = parseIndent();
+            if (indent) {
+              if (first) {
+                return parsePatternElements([first, indent], indent.length);
+              }
+              indent.value = trim(indent.value, RE_LEADING_NEWLINES);
+              return parsePatternElements([indent], indent.length);
+            }
+            if (first) {
+              return trim(first, RE_TRAILING_SPACES);
+            }
+            return null;
+          }
+          function parsePatternElements(elements = [], commonIndent) {
+            while (true) {
+              if (test(RE_TEXT_RUN)) {
+                elements.push(match1(RE_TEXT_RUN));
+                continue;
+              }
+              if (source[cursor] === "{") {
+                elements.push(parsePlaceable());
+                continue;
+              }
+              if (source[cursor] === "}") {
+                throw new SyntaxError("Unbalanced closing brace");
+              }
+              let indent = parseIndent();
+              if (indent) {
+                elements.push(indent);
+                commonIndent = Math.min(commonIndent, indent.length);
+                continue;
+              }
+              break;
+            }
+            let lastIndex = elements.length - 1;
+            let lastElement = elements[lastIndex];
+            if (typeof lastElement === "string") {
+              elements[lastIndex] = trim(lastElement, RE_TRAILING_SPACES);
+            }
+            let baked = [];
+            for (let element of elements) {
+              if (element instanceof Indent) {
+                element = element.value.slice(0, element.value.length - commonIndent);
+              }
+              if (element) {
+                baked.push(element);
+              }
+            }
+            return baked;
+          }
+          function parsePlaceable() {
+            consumeToken(TOKEN_BRACE_OPEN, SyntaxError);
+            let selector = parseInlineExpression();
+            if (consumeToken(TOKEN_BRACE_CLOSE)) {
+              return selector;
+            }
+            if (consumeToken(TOKEN_ARROW)) {
+              let variants = parseVariants();
+              consumeToken(TOKEN_BRACE_CLOSE, SyntaxError);
+              return {
+                type: "select",
+                selector,
+                ...variants
+              };
+            }
+            throw new SyntaxError("Unclosed placeable");
+          }
+          function parseInlineExpression() {
+            if (source[cursor] === "{") {
+              return parsePlaceable();
+            }
+            if (test(RE_REFERENCE)) {
+              let [, sigil, name, attr = null] = match2(RE_REFERENCE);
+              if (sigil === "$") {
+                return { type: "var", name };
+              }
+              if (consumeToken(TOKEN_PAREN_OPEN)) {
+                let args = parseArguments();
+                if (sigil === "-") {
+                  return { type: "term", name, attr, args };
+                }
+                if (RE_FUNCTION_NAME.test(name)) {
+                  return { type: "func", name, args };
+                }
+                throw new SyntaxError("Function names must be all upper-case");
+              }
+              if (sigil === "-") {
+                return {
+                  type: "term",
+                  name,
+                  attr,
+                  args: []
+                };
+              }
+              return { type: "mesg", name, attr };
+            }
+            return parseLiteral();
+          }
+          function parseArguments() {
+            let args = [];
+            while (true) {
+              switch (source[cursor]) {
+                case ")":
+                  cursor++;
+                  return args;
+                case void 0:
+                  throw new SyntaxError("Unclosed argument list");
+              }
+              args.push(parseArgument());
+              consumeToken(TOKEN_COMMA);
+            }
+          }
+          function parseArgument() {
+            let expr = parseInlineExpression();
+            if (expr.type !== "mesg") {
+              return expr;
+            }
+            if (consumeToken(TOKEN_COLON)) {
+              return {
+                type: "narg",
+                name: expr.name,
+                value: parseLiteral()
+              };
+            }
+            return expr;
+          }
+          function parseVariants() {
+            let variants = [];
+            let count = 0;
+            let star;
+            while (test(RE_VARIANT_START)) {
+              if (consumeChar("*")) {
+                star = count;
+              }
+              let key = parseVariantKey();
+              let value = parsePattern();
+              if (value === null) {
+                throw new SyntaxError("Expected variant value");
+              }
+              variants[count++] = { key, value };
+            }
+            if (count === 0) {
+              return null;
+            }
+            if (star === void 0) {
+              throw new SyntaxError("Expected default variant");
+            }
+            return { variants, star };
+          }
+          function parseVariantKey() {
+            consumeToken(TOKEN_BRACKET_OPEN, SyntaxError);
+            let key;
+            if (test(RE_NUMBER_LITERAL)) {
+              key = parseNumberLiteral();
+            } else {
+              key = {
+                type: "str",
+                value: match1(RE_IDENTIFIER)
+              };
+            }
+            consumeToken(TOKEN_BRACKET_CLOSE, SyntaxError);
+            return key;
+          }
+          function parseLiteral() {
+            if (test(RE_NUMBER_LITERAL)) {
+              return parseNumberLiteral();
+            }
+            if (source[cursor] === '"') {
+              return parseStringLiteral();
+            }
+            throw new SyntaxError("Invalid expression");
+          }
+          function parseNumberLiteral() {
+            let [, value, fraction = ""] = match2(RE_NUMBER_LITERAL);
+            let precision = fraction.length;
+            return {
+              type: "num",
+              value: parseFloat(value),
+              precision
+            };
+          }
+          function parseStringLiteral() {
+            consumeChar('"', SyntaxError);
+            let value = "";
+            while (true) {
+              value += match1(RE_STRING_RUN);
+              if (source[cursor] === "\\") {
+                value += parseEscapeSequence();
+                continue;
+              }
+              if (consumeChar('"')) {
+                return { type: "str", value };
+              }
+              throw new SyntaxError("Unclosed string literal");
+            }
+          }
+          function parseEscapeSequence() {
+            if (test(RE_STRING_ESCAPE)) {
+              return match1(RE_STRING_ESCAPE);
+            }
+            if (test(RE_UNICODE_ESCAPE)) {
+              let [, codepoint4, codepoint6] = match2(RE_UNICODE_ESCAPE);
+              let codepoint = parseInt(codepoint4 || codepoint6, 16);
+              return codepoint <= 55295 || 57344 <= codepoint ? (
+                // It's a Unicode scalar value.
+                String.fromCodePoint(codepoint)
+              ) : (
+                // Lonely surrogates can cause trouble when the parsing result is
+                // saved using UTF-8. Use U+FFFD REPLACEMENT CHARACTER instead.
+                "\uFFFD"
+              );
+            }
+            throw new SyntaxError("Unknown escape sequence");
+          }
+          function parseIndent() {
+            let start = cursor;
+            consumeToken(TOKEN_BLANK);
+            switch (source[cursor]) {
+              case ".":
+              case "[":
+              case "*":
+              case "}":
+              case void 0:
+                return false;
+              case "{":
+                return makeIndent(source.slice(start, cursor));
+            }
+            if (source[cursor - 1] === " ") {
+              return makeIndent(source.slice(start, cursor));
+            }
+            return false;
+          }
+          function trim(text, re) {
+            return text.replace(re, "");
+          }
+          function makeIndent(blank) {
+            let value = blank.replace(RE_BLANK_LINES, "\n");
+            let length = RE_INDENT.exec(blank)[1].length;
+            return new Indent(value, length);
+          }
+        }
+      }
+      class Indent {
+        constructor(value, length) {
+          this.value = value;
+          this.length = length;
+        }
+      }
+      exports2.FluentBundle = FluentBundle2;
+      exports2.FluentDateTime = FluentDateTime;
+      exports2.FluentNone = FluentNone;
+      exports2.FluentNumber = FluentNumber;
+      exports2.FluentResource = FluentResource2;
+      exports2.FluentType = FluentType;
+    }));
+  }
+});
+
+// src/main.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../core/src/types.ts
+var REJECT_REASONS = [
+  "unknown-scene",
+  "in-scene",
+  "wrong-place",
+  "locked",
+  "no-slots",
+  "stale-run",
+  "no-pick",
+  "bad-choice",
+  "no-tiles",
+  "bad-tile",
+  "not-linked",
+  "unknown-word"
+];
+var WALLET_REASONS = ["wages", "mixup", "food", "rent"];
+
+// ../core/src/combo.ts
+function comboKey(combo) {
+  return Object.keys(combo).sort().map((k) => `${k}=${combo[k]}`).join("|");
+}
+function parseComboKey(key) {
+  const out = {};
+  if (!key) return out;
+  for (const part of key.split("|")) {
+    const [k, v] = part.split("=");
+    out[k] = v;
+  }
+  return out;
+}
+function resolveParams(params, combo) {
+  const out = {};
+  for (const [k, v] of Object.entries(params)) out[k] = v.startsWith("$") ? combo[v.slice(1)] : v;
+  return out;
+}
+
+// ../core/src/learner.ts
+var DAY_MS = 864e5;
+var KNOWN_STREAK = 3;
+var MAX_INTERVAL_DAYS = 60;
+var RANK_THRESHOLDS = [0, 0.2, 0.4, 0.6, 0.85];
+function decayIntervalMs(streak) {
+  return Math.min(MAX_INTERVAL_DAYS, 2 ** (streak - 2)) * DAY_MS;
+}
+function wordState(rec, now) {
+  if (!rec) return "unseen";
+  if (rec.lapsed) return "shaky";
+  if (rec.streak >= KNOWN_STREAK) return now - rec.lastSeen > decayIntervalMs(rec.streak) ? "shaky" : "known";
+  return "met";
+}
+function base(rec, now) {
+  return rec ? { ...rec } : { right: 0, wrong: 0, streak: 0, helps: 0, lapsed: false, firstSeen: now, lastSeen: now };
+}
+function recordSeen(rec, now) {
+  const r = base(rec, now);
+  if (wordState(rec, now) === "shaky") r.lapsed = true;
+  r.lastSeen = now;
+  return r;
+}
+function recordRight(rec, now) {
+  const r = recordSeen(rec, now);
+  r.right += 1;
+  r.streak += 1;
+  r.lapsed = false;
+  return r;
+}
+function recordWrong(rec, now) {
+  const r = recordSeen(rec, now);
+  r.wrong += 1;
+  r.streak = 0;
+  r.lapsed = true;
+  return r;
+}
+function recordHelp(rec, now) {
+  const r = recordSeen(rec, now);
+  r.helps += 1;
+  r.streak = 0;
+  r.lapsed = true;
+  return r;
+}
+var MODE_RANK = { unseen: 0, met: 0, shaky: 1, known: 2 };
+function replyModeFor(states, typing) {
+  if (states.length === 0) return "pick";
+  const r = Math.min(...states.map((s) => MODE_RANK[s]));
+  if (r === 0) return "pick";
+  if (r === 1) return "tiles";
+  return typing ? "type" : "tiles";
+}
+function pickPreferred(candidates, wordsOf, records, now, rng) {
+  const prio = (c) => Math.min(
+    2,
+    ...wordsOf(c).map((w) => {
+      const s = wordState(records[w], now);
+      return s === "shaky" ? 0 : s === "met" ? 1 : 2;
+    })
+  );
+  if (candidates.length === 0) throw new Error("pickPreferred: no candidates");
+  const best = Math.min(...candidates.map(prio));
+  const pool = candidates.filter((c) => prio(c) === best);
+  return pool[Math.floor(rng() * pool.length)];
+}
+function rankFor(records, wordIds, now) {
+  if (wordIds.length === 0) return 0;
+  const known = wordIds.filter((w) => wordState(records[w], now) === "known").length;
+  const share = known / wordIds.length;
+  let rank = 0;
+  RANK_THRESHOLDS.forEach((t, i) => {
+    if (share >= t) rank = i;
+  });
+  return rank;
+}
+
+// ../core/src/life.ts
+function isAvailable(scene, state2) {
+  if (!scene.repeatable && (state2.scenesDone[scene.id] ?? 0) > 0) return false;
+  if (!scene.after.every((id) => (state2.scenesDone[id] ?? 0) > 0)) return false;
+  const trust = scene.requires.trust ?? {};
+  return Object.entries(trust).every(([npc, min]) => (state2.trust[npc] ?? 0) >= min);
+}
+function availableSceneIds(course2, state2) {
+  return course2.scenes.filter((s) => isAvailable(s, state2)).map((s) => s.id);
+}
+function changeWallet(state2, delta, reason) {
+  const next = Math.max(0, state2.wallet + delta);
+  const actual = next - state2.wallet;
+  state2.wallet = next;
+  return actual === 0 ? [] : [{ type: "walletChanged", wallet: next, delta: actual, reason }];
+}
+function addTrust(state2, npc, amount) {
+  if (amount <= 0) return [];
+  state2.trust[npc] = (state2.trust[npc] ?? 0) + amount;
+  return [{ type: "trustChanged", npc, trust: state2.trust[npc] }];
+}
+function endDay(course2, state2) {
+  const { foodPerDay, rentPerWeek } = course2.world;
+  const events = [{ type: "dayEnded", day: state2.day }];
+  events.push(...changeWallet(state2, -foodPerDay, "food"));
+  if (state2.day % 7 === 0 || state2.rentLate) {
+    if (state2.wallet >= rentPerWeek) {
+      events.push(...changeWallet(state2, -rentPerWeek, "rent"));
+      state2.rentLate = false;
+    } else {
+      state2.rentLate = true;
+    }
+  }
+  state2.day += 1;
+  state2.slot = 0;
+  return events;
+}
+function newGame(course2) {
+  return {
+    v: 1,
+    course: course2.id,
+    day: 1,
+    slot: 0,
+    wallet: course2.world.startWallet,
+    rentLate: false,
+    place: course2.world.start,
+    trust: {},
+    words: {},
+    scenesDone: {},
+    run: null
+  };
+}
+
+// ../core/src/rng.ts
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function shuffle(xs, rng) {
+  const a = [...xs];
+  for (let i = a.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    [a[i], a[j]] = [a[j], a[i]];
+  }
+  return a;
+}
+
+// ../core/src/dialogue.ts
+function reject(ctx, reason) {
+  ctx.ev.push({ type: "inputRejected", reason });
+}
+function setWord(ctx, word, update) {
+  const from = wordState(ctx.state.words[word], ctx.now);
+  ctx.state.words[word] = update(ctx.state.words[word], ctx.now);
+  const to = wordState(ctx.state.words[word], ctx.now);
+  if (from !== to) ctx.ev.push({ type: "wordStateChanged", word, from, to });
+}
+function tilePieces(line) {
+  return line.tokens.map((t) => line.text.slice(t.start, t.end));
+}
+function sceneById(ctx, id) {
+  return ctx.course.scenes.find((s) => s.id === id);
+}
+function hingeWords(ctx, ex, combo) {
+  const concepts = ex.hinges.map((h) => h.startsWith("$") ? combo[h.slice(1)] : h);
+  return [...new Set(concepts.flatMap((c) => ctx.course.concepts[c] ?? []))];
+}
+function chooseCombo(ctx, ex) {
+  const combo = {};
+  for (const slot of Object.keys(ex.slots).sort()) {
+    const values = ctx.course.groups[ex.slots[slot]];
+    combo[slot] = pickPreferred(values, (c) => ctx.course.concepts[c] ?? [], ctx.state.words, ctx.now, ctx.rng);
+  }
+  return combo;
+}
+function speak(ctx, npc, line) {
+  ctx.ev.push({ type: "lineSpoken", npc, line });
+  for (const t of line.tokens) setWord(ctx, t.word, recordSeen);
+}
+function pickOptions(ctx, ex, combo) {
+  const rightKey = comboKey(combo);
+  const texts = /* @__PURE__ */ new Set([ex.variants[rightKey].reply.text]);
+  const wrong = [];
+  for (const key of shuffle(Object.keys(ex.variants), ctx.rng)) {
+    if (wrong.length === 3) break;
+    const c = parseComboKey(key);
+    const differing = Object.keys(combo).filter((s) => c[s] !== combo[s]).length;
+    const text = ex.variants[key].reply.text;
+    if (differing === 1 && !texts.has(text)) {
+      texts.add(text);
+      wrong.push(key);
+    }
+  }
+  return shuffle([rightKey, ...wrong], ctx.rng);
+}
+function buildTiles(ctx, ex, combo) {
+  const rightKey = comboKey(combo);
+  const pieces = tilePieces(ex.variants[rightKey].reply);
+  const extra = /* @__PURE__ */ new Set();
+  for (const key of shuffle(Object.keys(ex.variants), ctx.rng)) {
+    if (key === rightKey) continue;
+    for (const p of tilePieces(ex.variants[key].reply)) if (!pieces.includes(p)) extra.add(p);
+    if (extra.size >= 2) break;
+  }
+  return shuffle([...pieces, ...[...extra].slice(0, 2)], ctx.rng);
+}
+function optionsEvent(ex, run) {
+  return run.mode === "pick" ? { type: "replyOptions", mode: "pick", options: run.options.map((k) => ex.variants[k].reply) } : { type: "replyOptions", mode: "tiles", tiles: run.tiles };
+}
+function emitOptions(ctx, ex) {
+  ctx.ev.push(optionsEvent(ex, ctx.state.run));
+}
+function describeRun(course2, state2) {
+  const run = state2.run;
+  const scene = run && course2.scenes.find((s) => s.id === run.scene);
+  const ex = scene?.exchanges[run.exchange];
+  const v = ex?.variants[comboKey(run.combo)];
+  if (!run || !scene || !ex || !v) return [];
+  return [
+    { type: "sceneStarted", scene: scene.id, npc: scene.npc },
+    { type: "lineSpoken", npc: scene.npc, line: v.npc },
+    optionsEvent(ex, run)
+  ];
+}
+function beginExchange(ctx, scene, index) {
+  const run = ctx.state.run;
+  const ex = scene.exchanges[index];
+  const combo = chooseCombo(ctx, ex);
+  speak(ctx, scene.npc, ex.variants[comboKey(combo)].npc);
+  const states = hingeWords(ctx, ex, combo).map((w) => wordState(ctx.state.words[w], ctx.now));
+  const mode = replyModeFor(states, ctx.course.typing);
+  run.exchange = index;
+  run.combo = combo;
+  run.misses = 0;
+  run.mode = mode === "type" ? "tiles" : mode;
+  run.options = run.mode === "pick" ? pickOptions(ctx, ex, combo) : [];
+  run.tiles = run.mode === "tiles" ? buildTiles(ctx, ex, combo) : [];
+  emitOptions(ctx, ex);
+}
+function finishScene(ctx, scene) {
+  const run = ctx.state.run;
+  ctx.state.run = null;
+  ctx.state.scenesDone[scene.id] = (ctx.state.scenesDone[scene.id] ?? 0) + 1;
+  ctx.ev.push({ type: "sceneEnded", scene: scene.id, earned: run.earned });
+  ctx.ev.push(...changeWallet(ctx.state, run.earned, "wages"));
+  ctx.ev.push(...addTrust(ctx.state, scene.npc, scene.trustGain + (run.mixups === 0 ? 1 : 0)));
+}
+function resolve(ctx, scene, ex, chosen, diff, tilesWrong = false) {
+  const run = ctx.state.run;
+  const matched = diff.length === 0 && !tilesWrong;
+  ctx.ev.push({ type: "actionPerformed", action: resolveParams(ex.expect, chosen), matched, diff, tilesWrong });
+  const hinges = hingeWords(ctx, ex, run.combo);
+  if (matched) {
+    for (const w of hinges) setWord(ctx, w, recordRight);
+    run.earned += ex.pay;
+    if (run.exchange + 1 < scene.exchanges.length) beginExchange(ctx, scene, run.exchange + 1);
+    else finishScene(ctx, scene);
+    return;
+  }
+  for (const w of hinges) setWord(ctx, w, recordWrong);
+  run.misses += 1;
+  run.mixups += 1;
+  ctx.ev.push(...changeWallet(ctx.state, -ex.missCost, "mixup"));
+  const reaction = diff.map((d) => `wrong-${d}`).find((r) => ctx.course.reactions[r]) ?? "wrong-generic";
+  ctx.ev.push({ type: "npcReacted", npc: scene.npc, reaction, line: ctx.course.reactions[reaction] });
+  if (run.misses >= 2) {
+    const v = ex.variants[comboKey(run.combo)];
+    const line = v.rephrase ?? v.npc;
+    ctx.ev.push({ type: "lineRephrased", npc: scene.npc, line, slow: !v.rephrase });
+    for (const t of line.tokens) setWord(ctx, t.word, recordSeen);
+  }
+  emitOptions(ctx, ex);
+}
+function startScene(ctx, id) {
+  const scene = sceneById(ctx, id);
+  if (!scene) return reject(ctx, "unknown-scene");
+  if (ctx.state.run) return reject(ctx, "in-scene");
+  if (scene.place !== ctx.state.place) return reject(ctx, "wrong-place");
+  if (!isAvailable(scene, ctx.state)) return reject(ctx, "locked");
+  if (ctx.state.slot >= ctx.course.world.slotsPerDay) return reject(ctx, "no-slots");
+  ctx.state.slot += 1;
+  ctx.state.run = {
+    scene: id,
+    exchange: 0,
+    combo: {},
+    mode: "pick",
+    options: [],
+    tiles: [],
+    misses: 0,
+    earned: 0,
+    mixups: 0
+  };
+  ctx.ev.push({ type: "sceneStarted", scene: id, npc: scene.npc });
+  beginExchange(ctx, scene, 0);
+}
+function current(ctx) {
+  const run = ctx.state.run;
+  if (!run) return void 0;
+  const scene = sceneById(ctx, run.scene);
+  const ex = scene?.exchanges[run.exchange];
+  if (!scene || !ex || !ex.variants[comboKey(run.combo)]) return void 0;
+  return { scene, ex };
+}
+function actionDiff(ex, chosen, expected) {
+  const got = resolveParams(ex.expect, chosen);
+  const want = resolveParams(ex.expect, expected);
+  return Object.keys(want).filter((k) => got[k] !== want[k]);
+}
+function reply(ctx, choice) {
+  const run = ctx.state.run;
+  if (run && !current(ctx)) return reject(ctx, "stale-run");
+  const cur = current(ctx);
+  if (!cur || !run || run.mode !== "pick") return reject(ctx, "no-pick");
+  const key = run.options[choice];
+  if (key === void 0) return reject(ctx, "bad-choice");
+  const chosen = parseComboKey(key);
+  resolve(ctx, cur.scene, cur.ex, chosen, actionDiff(cur.ex, chosen, run.combo));
+}
+function replyTiles(ctx, tiles) {
+  const run = ctx.state.run;
+  if (run && !current(ctx)) return reject(ctx, "stale-run");
+  const cur = current(ctx);
+  if (!cur || !run || run.mode !== "tiles") return reject(ctx, "no-tiles");
+  if (tiles.some((i) => run.tiles[i] === void 0)) return reject(ctx, "bad-tile");
+  const answer = tiles.map((i) => run.tiles[i]).join("");
+  const target = tilePieces(cur.ex.variants[comboKey(run.combo)].reply).join("");
+  resolve(ctx, cur.scene, cur.ex, run.combo, [], answer !== target);
+}
+
+// ../core/src/save.ts
+var SAVE_VERSION = 1;
+function serialize(state2) {
+  return JSON.stringify(state2);
+}
+var isObj = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+var isCount = (x) => Number.isInteger(x) && x >= 0;
+var isStrings = (x) => Array.isArray(x) && x.every((s) => typeof s === "string");
+var allValues = (o, ok) => Object.values(o).every(ok);
+function isWordRecord(x) {
+  if (!isObj(x) || typeof x.lapsed !== "boolean") return false;
+  return ["right", "wrong", "streak", "helps", "firstSeen", "lastSeen"].every((k) => isCount(x[k]));
+}
+function isRunShape(x) {
+  if (!isObj(x) || typeof x.scene !== "string" || !isObj(x.combo) || !allValues(x.combo, (v) => typeof v === "string"))
+    return false;
+  if (!["pick", "tiles", "type"].includes(x.mode) || !isStrings(x.options) || !isStrings(x.tiles)) return false;
+  return ["exchange", "misses", "earned", "mixups"].every((k) => isCount(x[k]));
+}
+function tilesCover(tiles, pieces) {
+  const left = [...tiles];
+  return pieces.every((p) => {
+    const i = left.indexOf(p);
+    return i >= 0 && left.splice(i, 1).length === 1;
+  });
+}
+function runFits(run, course2) {
+  const ex = course2.scenes.find((s) => s.id === run.scene)?.exchanges[run.exchange];
+  const v = ex?.variants[comboKey(run.combo)];
+  if (!ex || !v) return false;
+  if (run.mode === "pick") return run.options.every((k) => !!ex.variants[k]);
+  return tilesCover(run.tiles, tilePieces(v.reply));
+}
+function parseSave(raw, course2) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return { ok: false, reason: "not-json" };
+  }
+  if (!isObj(data)) return { ok: false, reason: "not-object" };
+  if (typeof data.v === "number" && data.v > SAVE_VERSION) return { ok: false, reason: "newer-version" };
+  if (data.v !== SAVE_VERSION) return { ok: false, reason: "version" };
+  if (data.course !== course2.id) return { ok: false, reason: "other-course" };
+  if (!isCount(data.day)) return { ok: false, reason: "bad-day" };
+  if (!isCount(data.slot) || data.slot > course2.world.slotsPerDay) return { ok: false, reason: "bad-slot" };
+  if (!isCount(data.wallet)) return { ok: false, reason: "bad-wallet" };
+  if (typeof data.rentLate !== "boolean") return { ok: false, reason: "bad-rentLate" };
+  if (typeof data.place !== "string" || !course2.world.places[data.place]) return { ok: false, reason: "bad-place" };
+  if (!isObj(data.trust) || !allValues(data.trust, isCount)) return { ok: false, reason: "bad-trust" };
+  if (!isObj(data.scenesDone) || !allValues(data.scenesDone, isCount)) return { ok: false, reason: "bad-scenesDone" };
+  if (!isObj(data.words) || !allValues(data.words, isWordRecord)) return { ok: false, reason: "bad-words" };
+  if (data.run !== null && !isRunShape(data.run)) return { ok: false, reason: "bad-run" };
+  const state2 = data;
+  if (state2.run && !runFits(state2.run, course2)) state2.run = null;
+  return { ok: true, state: state2 };
+}
+
+// ../core/src/core.ts
+function handle(ctx, input) {
+  const { course: course2, state: state2 } = ctx;
+  switch (input.type) {
+    case "goTo":
+      if (state2.run) return reject(ctx, "in-scene");
+      if (!course2.world.places[state2.place]?.links.includes(input.place)) return reject(ctx, "not-linked");
+      state2.place = input.place;
+      ctx.ev.push({ type: "placeEntered", place: input.place });
+      return;
+    case "startScene":
+      return startScene(ctx, input.scene);
+    case "reply":
+      return reply(ctx, input.choice);
+    case "replyTiles":
+      return replyTiles(ctx, input.tiles);
+    case "helpWord":
+      if (!course2.words[input.word]) return reject(ctx, "unknown-word");
+      return setWord(ctx, input.word, recordHelp);
+    case "sleep":
+      if (state2.run) return reject(ctx, "in-scene");
+      ctx.ev.push(...endDay(course2, state2));
+      return;
+  }
+}
+function createCore(course2, initial, deps) {
+  const wordIds = Object.keys(course2.words);
+  let state2 = initial;
+  return {
+    get state() {
+      return state2;
+    },
+    send(input) {
+      const now = deps.now();
+      const ctx = { course: course2, state: structuredClone(state2), now, rng: deps.rng, ev: [] };
+      handle(ctx, input);
+      if (ctx.ev.some((e) => e.type === "inputRejected")) return ctx.ev;
+      const before = new Set(availableSceneIds(course2, state2));
+      for (const id of availableSceneIds(course2, ctx.state)) {
+        if (!before.has(id)) ctx.ev.push({ type: "unlocked", scene: id });
+      }
+      const rank = rankFor(ctx.state.words, wordIds, now);
+      if (rank !== rankFor(state2.words, wordIds, now)) ctx.ev.push({ type: "rankChanged", rank });
+      state2 = ctx.state;
+      return ctx.ev;
+    }
+  };
+}
+
+// ../tui/src/width.ts
+var isControl = (cp) => cp < 32 || cp >= 127 && cp < 160;
+function charWidth(cp) {
+  if (isControl(cp)) return 0;
+  if (/[\p{Mn}\p{Cf}]/u.test(String.fromCodePoint(cp))) return 0;
+  if (cp >= 4352 && cp <= 4447 || cp >= 11904 && cp <= 42191 || cp >= 44032 && cp <= 55203 || cp >= 63744 && cp <= 64255 || cp >= 65072 && cp <= 65103 || cp >= 65280 && cp <= 65376 || cp >= 65504 && cp <= 65510 || cp === 126980 || cp >= 127744 && cp <= 129791 || cp >= 131072 && cp <= 262141) {
+    return 2;
+  }
+  return 1;
+}
+function strWidth(s) {
+  let w = 0;
+  for (const ch of s) w += charWidth(ch.codePointAt(0));
+  return w;
+}
+function fitLine(line, cols) {
+  const out = [];
+  let used = 0;
+  for (const span of line) {
+    let text = "";
+    for (const raw of span.text) {
+      const ch = isControl(raw.codePointAt(0)) ? " " : raw;
+      const w = charWidth(ch.codePointAt(0));
+      if (used + w > cols) break;
+      text += ch;
+      used += w;
+    }
+    if (text) out.push({ ...span, text });
+    if (used >= cols) break;
+  }
+  if (used < cols) out.push({ text: " ".repeat(cols - used) });
+  return out;
+}
+
+// ../tui/src/text.ts
+var import_bundle = __toESM(require_bundle(), 1);
+function makeText(ftl, locale = "en") {
+  const bundle = new import_bundle.FluentBundle(locale, { useIsolating: false });
+  bundle.addResource(new import_bundle.FluentResource(ftl));
+  return (id, args) => {
+    const msg = bundle.getMessage(id);
+    return msg?.value ? bundle.formatPattern(msg.value, args ?? {}, []) : id;
+  };
+}
+var UI_KEYS = {
+  hud: ["day", "slot", "slots", "currency", "wallet", "rank"],
+  "rank-0": [],
+  "rank-1": [],
+  "rank-2": [],
+  "rank-3": [],
+  "rank-4": [],
+  "menu-title": [],
+  "menu-talk": ["npc", "scene"],
+  "menu-go": ["place"],
+  "menu-sleep": [],
+  "menu-quit": [],
+  "keys-explore": [],
+  "keys-pick": [],
+  "keys-tiles": [],
+  "keys-help": [],
+  "help-title": [],
+  "tiles-answer": [],
+  mismatch: [],
+  rephrased: [],
+  "wallet-change": ["sign", "currency", "amount", "reason"],
+  ...Object.fromEntries(WALLET_REASONS.map((r) => [`reason-${r}`, []])),
+  "trust-up": ["npc", "trust"],
+  "scene-done": ["currency", "earned"],
+  unlocked: ["scene"],
+  "rank-up": ["rank"],
+  "day-ended": ["day"],
+  "notice-bad-save": [],
+  "notice-read-only": [],
+  ...Object.fromEntries(REJECT_REASONS.map((c) => [`reject-${c}`, []]))
+};
+
+// ../tui/src/screen.ts
+function lineSpans(line, fresh) {
+  const out = [];
+  let at = 0;
+  for (const t of line.tokens) {
+    if (t.start > at) out.push({ text: line.text.slice(at, t.start) });
+    out.push({ text: line.text.slice(t.start, t.end), underline: fresh.has(t.word) });
+    at = t.end;
+  }
+  if (at < line.text.length) out.push({ text: line.text.slice(at) });
+  return out;
+}
+function wrapItems(items, width, gap = "  ") {
+  const lines = [];
+  for (const item of items) {
+    const last = lines.at(-1);
+    if (last !== void 0 && strWidth(last) + strWidth(gap) + strWidth(item) <= width) lines[lines.length - 1] = last + gap + item;
+    else lines.push(item);
+  }
+  return lines.map((text) => [{ text }]);
+}
+function border(left, label, right, fill, cols, rightLabel = "") {
+  const inner = cols - 2;
+  const l = label ? ` ${label} ` : "";
+  const r = rightLabel ? ` ${rightLabel} ` : "";
+  const gap = Math.max(0, inner - strWidth(l) - strWidth(r));
+  return fitLine(
+    [
+      { text: left, dim: true },
+      { text: l, bold: true },
+      { text: fill.repeat(gap), dim: true },
+      { text: r },
+      { text: right, dim: true }
+    ],
+    cols
+  );
+}
+function renderScreen(m, cols, rows) {
+  const inner = Math.max(1, cols - 4);
+  const bodyRows = Math.max(1, rows - 2);
+  const prompt = m.prompt.slice(-bodyRows);
+  const logRows = Math.max(0, bodyRows - prompt.length - (prompt.length ? 1 : 0));
+  const log = logRows > 0 ? m.log.slice(-logRows) : [];
+  const body = [...Array(logRows - log.length).fill([]), ...log];
+  if (prompt.length) body.push([]);
+  body.push(...prompt);
+  return [
+    border("\u250C", m.title, "\u2510", "\u2500", cols, m.hud),
+    ...body.map((l) => [{ text: "\u2502 ", dim: true }, ...fitLine(l, inner), { text: " \u2502", dim: true }]),
+    border("\u2514", m.footer, "\u2518", "\u2500", cols)
+  ];
+}
+
+// ../tui/src/app.ts
+var LOG_LIMIT = 200;
+function startApp(opts) {
+  const { course: course2, core: core2, term: term2 } = opts;
+  const t = makeText(course2.learnerFtl);
+  const wordIds = Object.keys(course2.words);
+  let mode = "explore";
+  let log = [];
+  let pickOptions2 = [];
+  let tiles = [];
+  let replyMode = "pick";
+  let tileInput = [];
+  let lastLine = null;
+  const push = (...lines) => {
+    log = [...log, ...lines].slice(-LOG_LIMIT);
+  };
+  const npcName = (npc) => t(`npc-${npc}`);
+  const say = (npc, line, fresh, suffix = "") => [
+    { text: `${npcName(npc)}${suffix}: `, color: "cyan", bold: true },
+    ...lineSpans(line, fresh)
+  ];
+  function enterPlace(place) {
+    push([], [{ text: t(`place-${place}`), bold: true }], [{ text: t(`place-${place}-desc`), dim: true }]);
+  }
+  function apply(events) {
+    const fresh = new Set(
+      events.flatMap((e) => e.type === "wordStateChanged" && e.from === "unseen" ? [e.word] : [])
+    );
+    for (const e of events) {
+      switch (e.type) {
+        case "placeEntered":
+          enterPlace(e.place);
+          break;
+        case "sceneStarted":
+          mode = "scene";
+          push([]);
+          break;
+        case "lineSpoken":
+          lastLine = e.line;
+          push(say(e.npc, e.line, fresh));
+          break;
+        case "replyOptions":
+          replyMode = e.mode;
+          tileInput = [];
+          if (e.mode === "pick") pickOptions2 = e.options;
+          else tiles = e.tiles;
+          break;
+        case "actionPerformed":
+          if (!e.matched) push([{ text: t("mismatch"), color: "yellow" }]);
+          break;
+        case "npcReacted":
+          push(say(e.npc, e.line, fresh));
+          break;
+        case "lineRephrased":
+          lastLine = e.line;
+          push(say(e.npc, e.line, fresh, ` ${t("rephrased")}`));
+          break;
+        case "walletChanged":
+          push([
+            {
+              text: t("wallet-change", {
+                sign: e.delta > 0 ? "+" : "-",
+                amount: Math.abs(e.delta),
+                currency: course2.world.currency,
+                reason: t(`reason-${e.reason}`)
+              }),
+              color: e.delta > 0 ? "green" : "red"
+            }
+          ]);
+          break;
+        case "trustChanged":
+          push([{ text: t("trust-up", { npc: npcName(e.npc), trust: e.trust }), color: "magenta" }]);
+          break;
+        case "sceneEnded":
+          mode = "explore";
+          push([{ text: t("scene-done", { currency: course2.world.currency, earned: e.earned }), bold: true }]);
+          break;
+        case "unlocked":
+          push([{ text: t("unlocked", { scene: t(`scene-${e.scene}`) }), color: "green" }]);
+          break;
+        case "rankChanged":
+          push([{ text: t("rank-up", { rank: t(`rank-${e.rank}`) }), color: "yellow", bold: true }]);
+          break;
+        case "dayEnded":
+          push([], [{ text: t("day-ended", { day: e.day }), dim: true }]);
+          break;
+        case "inputRejected":
+          push([{ text: t(`reject-${e.reason}`), color: "red" }]);
+          break;
+        case "wordStateChanged":
+          break;
+      }
+    }
+  }
+  let save = opts.save;
+  function persist() {
+    if (save && !save(core2.state)) {
+      save = void 0;
+      push([{ text: t("notice-read-only"), color: "yellow" }]);
+    }
+  }
+  function send(input) {
+    const events = core2.send(input);
+    apply(events);
+    if (!events.some((e) => e.type === "inputRejected")) persist();
+  }
+  function menu() {
+    const s = core2.state;
+    const items = [];
+    for (const id of availableSceneIds(course2, s)) {
+      const scene = course2.scenes.find((x) => x.id === id);
+      if (scene.place !== s.place) continue;
+      items.push({ label: t("menu-talk", { npc: npcName(scene.npc), scene: t(`scene-${id}`) }), input: { type: "startScene", scene: id } });
+    }
+    for (const p of course2.world.places[s.place].links) {
+      items.push({ label: t("menu-go", { place: t(`place-${p}`) }), input: { type: "goTo", place: p } });
+    }
+    return [...items.slice(0, 7), { label: t("menu-sleep"), input: { type: "sleep" } }, { label: t("menu-quit"), quit: true }];
+  }
+  function helpWords() {
+    if (!lastLine) return [];
+    const line = lastLine;
+    return line.tokens.map((tk) => ({ text: line.text.slice(tk.start, tk.end), word: tk.word }));
+  }
+  function prompt(width) {
+    if (mode === "explore") {
+      return [[{ text: t("menu-title"), dim: true }], ...menu().map((m, i) => [{ text: `${i + 1}) ${m.label}` }])];
+    }
+    if (mode === "help") {
+      const words = helpWords().map((w, i) => `${i + 1}) ${w.text}`);
+      return [[{ text: t("help-title"), dim: true }], ...wrapItems(words, width)];
+    }
+    if (replyMode === "pick") return pickOptions2.map((o, i) => [{ text: `${i + 1}) ` }, ...lineSpans(o, /* @__PURE__ */ new Set())]);
+    return [
+      ...wrapItems(
+        tiles.map((x, i) => `[${i + 1}]${x}`),
+        width,
+        " "
+      ),
+      [{ text: `${t("tiles-answer")} `, dim: true }, { text: tileInput.map((i) => tiles[i]).join(""), bold: true }]
+    ];
+  }
+  function render() {
+    const s = core2.state;
+    const { cols, rows } = term2.size();
+    const hud = t("hud", {
+      day: s.day,
+      slot: s.slot,
+      slots: course2.world.slotsPerDay,
+      currency: course2.world.currency,
+      wallet: s.wallet,
+      rank: t(`rank-${rankFor(s.words, wordIds, opts.now())}`)
+    });
+    const footer = t(mode === "explore" ? "keys-explore" : mode === "help" ? "keys-help" : replyMode === "pick" ? "keys-pick" : "keys-tiles");
+    term2.write(renderScreen({ title: t(`place-${s.place}`), hud, log, prompt: prompt(cols - 4), footer }, cols, rows));
+  }
+  function press(key) {
+    if (key.name === "ctrl-c") return opts.quit();
+    const n = /^[1-9]$/.test(key.name) ? Number(key.name) - 1 : -1;
+    if (mode === "explore") {
+      const item = n >= 0 ? menu()[n] : void 0;
+      if (key.name === "q" || item?.quit) return opts.quit();
+      if (item?.input) send(item.input);
+    } else if (mode === "help") {
+      const word = n >= 0 ? helpWords()[n] : void 0;
+      if (word) {
+        send({ type: "helpWord", word: word.word });
+        const w = course2.words[word.word];
+        push([
+          { text: w.w, bold: true },
+          ...w.pron ? [{ text: ` ${w.pron}`, color: "yellow" }] : [],
+          { text: ` \u2014 ${w.gloss}` }
+        ]);
+      }
+      if (key.name === "escape" || key.name === "w") mode = "scene";
+    } else if (key.name === "w") {
+      mode = "help";
+    } else if (replyMode === "pick") {
+      if (n >= 0 && n < pickOptions2.length) send({ type: "reply", choice: n });
+    } else if (n >= 0 && n < tiles.length && !tileInput.includes(n)) {
+      tileInput = [...tileInput, n];
+    } else if (key.name === "backspace") {
+      tileInput = tileInput.slice(0, -1);
+    } else if (key.name === "return" && tileInput.length) {
+      send({ type: "replyTiles", tiles: tileInput });
+    }
+    render();
+  }
+  if (opts.notice) push([{ text: t(opts.notice), color: "yellow" }]);
+  enterPlace(core2.state.place);
+  apply(describeRun(course2, core2.state));
+  term2.onKey(press);
+  term2.onResize(render);
+  render();
+  return { press, render };
+}
+
+// src/node-terminal.ts
+import readline from "node:readline";
+var COLORS = { red: 31, green: 32, yellow: 33, magenta: 35, cyan: 36 };
+function toAnsi(line) {
+  return line.map((s) => {
+    const codes = [
+      ...s.bold ? [1] : [],
+      ...s.dim ? [2] : [],
+      ...s.underline ? [4] : [],
+      ...s.color ? [COLORS[s.color]] : []
+    ];
+    return codes.length ? `\x1B[${codes.join(";")}m${s.text}\x1B[0m` : s.text;
+  }).join("");
+}
+function keyName(str, key) {
+  if (key?.ctrl && key.name === "c") return "ctrl-c";
+  return key?.name ?? str;
+}
+function createNodeTerminal(input = process.stdin, output = process.stdout) {
+  readline.emitKeypressEvents(input);
+  if (input.isTTY) input.setRawMode(true);
+  output.write("\x1B[?1049h\x1B[?25l");
+  const handlers = [];
+  input.on("keypress", (str, key) => {
+    const name = keyName(str, key);
+    if (name) for (const h of handlers) h({ name });
+  });
+  input.on("end", () => {
+    for (const h of handlers) h({ name: "ctrl-c" });
+  });
+  let closed = false;
+  const restore = () => {
+    if (closed) return;
+    closed = true;
+    if (input.isTTY) input.setRawMode(false);
+    input.pause();
+    output.write("\x1B[0m\x1B[?25h\x1B[?1049l");
+  };
+  process.on("exit", restore);
+  return {
+    write(lines) {
+      output.write("\x1B[H\x1B[2J" + lines.map(toAnsi).join("\r\n"));
+    },
+    onKey(handler) {
+      handlers.push(handler);
+    },
+    onResize(handler) {
+      output.on("resize", handler);
+    },
+    size() {
+      return { cols: output.columns || 80, rows: output.rows || 24 };
+    },
+    /** Restores the terminal. Safe to call more than once. */
+    close: restore
+  };
+}
+
+// src/storage.ts
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, writeSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function configDir(env = process.env, platform = process.platform, home = homedir()) {
+  if (platform === "win32") return env.APPDATA || join(home, "AppData", "Roaming");
+  return env.XDG_CONFIG_HOME || join(home, ".config");
+}
+function loadSave(course2, path) {
+  try {
+    if (!existsSync(path)) return { state: newGame(course2), readOnly: false };
+    const parsed = parseSave(readFileSync(path, "utf8"), course2);
+    if (parsed.ok) return { state: parsed.state, readOnly: false };
+    renameSync(path, `${path}.invalid-backup`);
+    return { state: newGame(course2), notice: "notice-bad-save", readOnly: false };
+  } catch {
+    return { state: newGame(course2), notice: "notice-read-only", readOnly: true };
+  }
+}
+function writeSave(path, state2) {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp`;
+    const fd = openSync(tmp, "w");
+    try {
+      writeSync(fd, serialize(state2));
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    renameSync(tmp, path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/main.ts
+var COURSE = "zh-china-en";
+function coursePath() {
+  if (process.argv[2]) return process.argv[2];
+  const candidates = [
+    new URL(`./courses/${COURSE}/course.json`, import.meta.url),
+    new URL(`../../../dist/courses/${COURSE}/course.json`, import.meta.url)
+  ].map((u) => fileURLToPath(u));
+  const found = candidates.find((p) => existsSync2(p));
+  if (!found) {
+    console.error(`No built course found. Run: npm run build:course`);
+    process.exit(1);
+  }
+  return found;
+}
+var [major] = process.versions.node.split(".").map(Number);
+if (major < 22) {
+  console.error(`silver-tongue needs Node 22 or newer; this is Node ${process.versions.node}.`);
+  process.exit(1);
+}
+var course = JSON.parse(readFileSync2(coursePath(), "utf8"));
+var savePath = process.env.SILVER_TONGUE_SAVE ?? join2(configDir(), "silver-tongue", `${course.id}.json`);
+var { state, notice, readOnly } = loadSave(course, savePath);
+var core = createCore(course, state, { now: Date.now, rng: mulberry32(Date.now() >>> 0) });
+var term = createNodeTerminal();
+var bail = (code, error) => {
+  term.close();
+  if (error) console.error(error);
+  process.exit(code);
+};
+process.on("uncaughtException", (e) => bail(1, e));
+process.on("unhandledRejection", (e) => bail(1, e));
+process.on("SIGTERM", () => bail(143));
+process.on("SIGHUP", () => bail(129));
+startApp({
+  course,
+  core,
+  term,
+  now: Date.now,
+  notice,
+  save: readOnly ? void 0 : (s) => writeSave(savePath, s),
+  quit: () => bail(0)
+});