dreamboard 0.1.0

package/dist/chunk-FK6CWXQR.js

@@ -0,0 +1,3479 @@
+#!/usr/bin/env node
+
+// ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/core.mjs
+var LogLevels = {
+  silent: Number.NEGATIVE_INFINITY,
+  fatal: 0,
+  error: 0,
+  warn: 1,
+  log: 2,
+  info: 3,
+  success: 3,
+  fail: 3,
+  ready: 3,
+  start: 3,
+  box: 3,
+  debug: 4,
+  trace: 5,
+  verbose: Number.POSITIVE_INFINITY
+};
+var LogTypes = {
+  // Silent
+  silent: {
+    level: -1
+  },
+  // Level 0
+  fatal: {
+    level: LogLevels.fatal
+  },
+  error: {
+    level: LogLevels.error
+  },
+  // Level 1
+  warn: {
+    level: LogLevels.warn
+  },
+  // Level 2
+  log: {
+    level: LogLevels.log
+  },
+  // Level 3
+  info: {
+    level: LogLevels.info
+  },
+  success: {
+    level: LogLevels.success
+  },
+  fail: {
+    level: LogLevels.fail
+  },
+  ready: {
+    level: LogLevels.info
+  },
+  start: {
+    level: LogLevels.info
+  },
+  box: {
+    level: LogLevels.info
+  },
+  // Level 4
+  debug: {
+    level: LogLevels.debug
+  },
+  // Level 5
+  trace: {
+    level: LogLevels.trace
+  },
+  // Verbose
+  verbose: {
+    level: LogLevels.verbose
+  }
+};
+function isPlainObject$1(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject$1(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject$1(value) && isPlainObject$1(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c2) => _defu(p, c2, "", merger), {})
+  );
+}
+var defu = createDefu();
+function isPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === "[object Object]";
+}
+function isLogObj(arg) {
+  if (!isPlainObject(arg)) {
+    return false;
+  }
+  if (!arg.message && !arg.args) {
+    return false;
+  }
+  if (arg.stack) {
+    return false;
+  }
+  return true;
+}
+var paused = false;
+var queue = [];
+var Consola = class _Consola {
+  options;
+  _lastLog;
+  _mockFn;
+  /**
+   * Creates an instance of Consola with specified options or defaults.
+   *
+   * @param {Partial<ConsolaOptions>} [options={}] - Configuration options for the Consola instance.
+   */
+  constructor(options = {}) {
+    const types = options.types || LogTypes;
+    this.options = defu(
+      {
+        ...options,
+        defaults: { ...options.defaults },
+        level: _normalizeLogLevel(options.level, types),
+        reporters: [...options.reporters || []]
+      },
+      {
+        types: LogTypes,
+        throttle: 1e3,
+        throttleMin: 5,
+        formatOptions: {
+          date: true,
+          colors: false,
+          compact: true
+        }
+      }
+    );
+    for (const type in types) {
+      const defaults = {
+        type,
+        ...this.options.defaults,
+        ...types[type]
+      };
+      this[type] = this._wrapLogFn(defaults);
+      this[type].raw = this._wrapLogFn(
+        defaults,
+        true
+      );
+    }
+    if (this.options.mockFn) {
+      this.mockTypes();
+    }
+    this._lastLog = {};
+  }
+  /**
+   * Gets the current log level of the Consola instance.
+   *
+   * @returns {number} The current log level.
+   */
+  get level() {
+    return this.options.level;
+  }
+  /**
+   * Sets the minimum log level that will be output by the instance.
+   *
+   * @param {number} level - The new log level to set.
+   */
+  set level(level) {
+    this.options.level = _normalizeLogLevel(
+      level,
+      this.options.types,
+      this.options.level
+    );
+  }
+  /**
+   * Displays a prompt to the user and returns the response.
+   * Throw an error if `prompt` is not supported by the current configuration.
+   *
+   * @template T
+   * @param {string} message - The message to display in the prompt.
+   * @param {T} [opts] - Optional options for the prompt. See {@link PromptOptions}.
+   * @returns {promise<T>} A promise that infer with the prompt options. See {@link PromptOptions}.
+   */
+  prompt(message, opts) {
+    if (!this.options.prompt) {
+      throw new Error("prompt is not supported!");
+    }
+    return this.options.prompt(message, opts);
+  }
+  /**
+   * Creates a new instance of Consola, inheriting options from the current instance, with possible overrides.
+   *
+   * @param {Partial<ConsolaOptions>} options - Optional overrides for the new instance. See {@link ConsolaOptions}.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  create(options) {
+    const instance = new _Consola({
+      ...this.options,
+      ...options
+    });
+    if (this._mockFn) {
+      instance.mockTypes(this._mockFn);
+    }
+    return instance;
+  }
+  /**
+   * Creates a new Consola instance with the specified default log object properties.
+   *
+   * @param {InputLogObject} defaults - Default properties to include in any log from the new instance. See {@link InputLogObject}.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  withDefaults(defaults) {
+    return this.create({
+      ...this.options,
+      defaults: {
+        ...this.options.defaults,
+        ...defaults
+      }
+    });
+  }
+  /**
+   * Creates a new Consola instance with a specified tag, which will be included in every log.
+   *
+   * @param {string} tag - The tag to include in each log of the new instance.
+   * @returns {ConsolaInstance} A new Consola instance. See {@link ConsolaInstance}.
+   */
+  withTag(tag) {
+    return this.withDefaults({
+      tag: this.options.defaults.tag ? this.options.defaults.tag + ":" + tag : tag
+    });
+  }
+  /**
+   * Adds a custom reporter to the Consola instance.
+   * Reporters will be called for each log message, depending on their implementation and log level.
+   *
+   * @param {ConsolaReporter} reporter - The reporter to add. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  addReporter(reporter) {
+    this.options.reporters.push(reporter);
+    return this;
+  }
+  /**
+   * Removes a custom reporter from the Consola instance.
+   * If no reporter is specified, all reporters will be removed.
+   *
+   * @param {ConsolaReporter} reporter - The reporter to remove. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  removeReporter(reporter) {
+    if (reporter) {
+      const i2 = this.options.reporters.indexOf(reporter);
+      if (i2 !== -1) {
+        return this.options.reporters.splice(i2, 1);
+      }
+    } else {
+      this.options.reporters.splice(0);
+    }
+    return this;
+  }
+  /**
+   * Replaces all reporters of the Consola instance with the specified array of reporters.
+   *
+   * @param {ConsolaReporter[]} reporters - The new reporters to set. See {@link ConsolaReporter}.
+   * @returns {Consola} The current Consola instance.
+   */
+  setReporters(reporters) {
+    this.options.reporters = Array.isArray(reporters) ? reporters : [reporters];
+    return this;
+  }
+  wrapAll() {
+    this.wrapConsole();
+    this.wrapStd();
+  }
+  restoreAll() {
+    this.restoreConsole();
+    this.restoreStd();
+  }
+  /**
+   * Overrides console methods with Consola logging methods for consistent logging.
+   */
+  wrapConsole() {
+    for (const type in this.options.types) {
+      if (!console["__" + type]) {
+        console["__" + type] = console[type];
+      }
+      console[type] = this[type].raw;
+    }
+  }
+  /**
+   * Restores the original console methods, removing Consola overrides.
+   */
+  restoreConsole() {
+    for (const type in this.options.types) {
+      if (console["__" + type]) {
+        console[type] = console["__" + type];
+        delete console["__" + type];
+      }
+    }
+  }
+  /**
+   * Overrides standard output and error streams to redirect them through Consola.
+   */
+  wrapStd() {
+    this._wrapStream(this.options.stdout, "log");
+    this._wrapStream(this.options.stderr, "log");
+  }
+  _wrapStream(stream, type) {
+    if (!stream) {
+      return;
+    }
+    if (!stream.__write) {
+      stream.__write = stream.write;
+    }
+    stream.write = (data) => {
+      this[type].raw(String(data).trim());
+    };
+  }
+  /**
+   * Restores the original standard output and error streams, removing the Consola redirection.
+   */
+  restoreStd() {
+    this._restoreStream(this.options.stdout);
+    this._restoreStream(this.options.stderr);
+  }
+  _restoreStream(stream) {
+    if (!stream) {
+      return;
+    }
+    if (stream.__write) {
+      stream.write = stream.__write;
+      delete stream.__write;
+    }
+  }
+  /**
+   * Pauses logging, queues incoming logs until resumed.
+   */
+  pauseLogs() {
+    paused = true;
+  }
+  /**
+   * Resumes logging, processing any queued logs.
+   */
+  resumeLogs() {
+    paused = false;
+    const _queue = queue.splice(0);
+    for (const item of _queue) {
+      item[0]._logFn(item[1], item[2]);
+    }
+  }
+  /**
+   * Replaces logging methods with mocks if a mock function is provided.
+   *
+   * @param {ConsolaOptions["mockFn"]} mockFn - The function to use for mocking logging methods. See {@link ConsolaOptions["mockFn"]}.
+   */
+  mockTypes(mockFn) {
+    const _mockFn = mockFn || this.options.mockFn;
+    this._mockFn = _mockFn;
+    if (typeof _mockFn !== "function") {
+      return;
+    }
+    for (const type in this.options.types) {
+      this[type] = _mockFn(type, this.options.types[type]) || this[type];
+      this[type].raw = this[type];
+    }
+  }
+  _wrapLogFn(defaults, isRaw) {
+    return (...args) => {
+      if (paused) {
+        queue.push([this, defaults, args, isRaw]);
+        return;
+      }
+      return this._logFn(defaults, args, isRaw);
+    };
+  }
+  _logFn(defaults, args, isRaw) {
+    if ((defaults.level || 0) > this.level) {
+      return false;
+    }
+    const logObj = {
+      date: /* @__PURE__ */ new Date(),
+      args: [],
+      ...defaults,
+      level: _normalizeLogLevel(defaults.level, this.options.types)
+    };
+    if (!isRaw && args.length === 1 && isLogObj(args[0])) {
+      Object.assign(logObj, args[0]);
+    } else {
+      logObj.args = [...args];
+    }
+    if (logObj.message) {
+      logObj.args.unshift(logObj.message);
+      delete logObj.message;
+    }
+    if (logObj.additional) {
+      if (!Array.isArray(logObj.additional)) {
+        logObj.additional = logObj.additional.split("\n");
+      }
+      logObj.args.push("\n" + logObj.additional.join("\n"));
+      delete logObj.additional;
+    }
+    logObj.type = typeof logObj.type === "string" ? logObj.type.toLowerCase() : "log";
+    logObj.tag = typeof logObj.tag === "string" ? logObj.tag : "";
+    const resolveLog = (newLog = false) => {
+      const repeated = (this._lastLog.count || 0) - this.options.throttleMin;
+      if (this._lastLog.object && repeated > 0) {
+        const args2 = [...this._lastLog.object.args];
+        if (repeated > 1) {
+          args2.push(`(repeated ${repeated} times)`);
+        }
+        this._log({ ...this._lastLog.object, args: args2 });
+        this._lastLog.count = 1;
+      }
+      if (newLog) {
+        this._lastLog.object = logObj;
+        this._log(logObj);
+      }
+    };
+    clearTimeout(this._lastLog.timeout);
+    const diffTime = this._lastLog.time && logObj.date ? logObj.date.getTime() - this._lastLog.time.getTime() : 0;
+    this._lastLog.time = logObj.date;
+    if (diffTime < this.options.throttle) {
+      try {
+        const serializedLog = JSON.stringify([
+          logObj.type,
+          logObj.tag,
+          logObj.args
+        ]);
+        const isSameLog = this._lastLog.serialized === serializedLog;
+        this._lastLog.serialized = serializedLog;
+        if (isSameLog) {
+          this._lastLog.count = (this._lastLog.count || 0) + 1;
+          if (this._lastLog.count > this.options.throttleMin) {
+            this._lastLog.timeout = setTimeout(
+              resolveLog,
+              this.options.throttle
+            );
+            return;
+          }
+        }
+      } catch {
+      }
+    }
+    resolveLog(true);
+  }
+  _log(logObj) {
+    for (const reporter of this.options.reporters) {
+      reporter.log(logObj, {
+        options: this.options
+      });
+    }
+  }
+};
+function _normalizeLogLevel(input, types = {}, defaultLevel = 3) {
+  if (input === void 0) {
+    return defaultLevel;
+  }
+  if (typeof input === "number") {
+    return input;
+  }
+  if (types[input] && types[input].level !== void 0) {
+    return types[input].level;
+  }
+  return defaultLevel;
+}
+Consola.prototype.add = Consola.prototype.addReporter;
+Consola.prototype.remove = Consola.prototype.removeReporter;
+Consola.prototype.clear = Consola.prototype.removeReporter;
+Consola.prototype.withScope = Consola.prototype.withTag;
+Consola.prototype.mock = Consola.prototype.mockTypes;
+Consola.prototype.pause = Consola.prototype.pauseLogs;
+Consola.prototype.resume = Consola.prototype.resumeLogs;
+function createConsola(options = {}) {
+  return new Consola(options);
+}
+
+// ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/shared/consola.DRwqZj3T.mjs
+import { formatWithOptions } from "util";
+import { sep } from "path";
+function parseStack(stack, message) {
+  const cwd = process.cwd() + sep;
+  const lines = stack.split("\n").splice(message.split("\n").length).map((l2) => l2.trim().replace("file://", "").replace(cwd, ""));
+  return lines;
+}
+function writeStream(data, stream) {
+  const write = stream.__write || stream.write;
+  return write.call(stream, data);
+}
+var bracket = (x) => x ? `[${x}]` : "";
+var BasicReporter = class {
+  formatStack(stack, message, opts) {
+    const indent = "  ".repeat((opts?.errorLevel || 0) + 1);
+    return indent + parseStack(stack, message).join(`
+${indent}`);
+  }
+  formatError(err, opts) {
+    const message = err.message ?? formatWithOptions(opts, err);
+    const stack = err.stack ? this.formatStack(err.stack, message, opts) : "";
+    const level = opts?.errorLevel || 0;
+    const causedPrefix = level > 0 ? `${"  ".repeat(level)}[cause]: ` : "";
+    const causedError = err.cause ? "\n\n" + this.formatError(err.cause, { ...opts, errorLevel: level + 1 }) : "";
+    return causedPrefix + message + "\n" + stack + causedError;
+  }
+  formatArgs(args, opts) {
+    const _args = args.map((arg) => {
+      if (arg && typeof arg.stack === "string") {
+        return this.formatError(arg, opts);
+      }
+      return arg;
+    });
+    return formatWithOptions(opts, ..._args);
+  }
+  formatDate(date, opts) {
+    return opts.date ? date.toLocaleTimeString() : "";
+  }
+  filterAndJoin(arr) {
+    return arr.filter(Boolean).join(" ");
+  }
+  formatLogObj(logObj, opts) {
+    const message = this.formatArgs(logObj.args, opts);
+    if (logObj.type === "box") {
+      return "\n" + [
+        bracket(logObj.tag),
+        logObj.title && logObj.title,
+        ...message.split("\n")
+      ].filter(Boolean).map((l2) => " > " + l2).join("\n") + "\n";
+    }
+    return this.filterAndJoin([
+      bracket(logObj.type),
+      bracket(logObj.tag),
+      message
+    ]);
+  }
+  log(logObj, ctx) {
+    const line = this.formatLogObj(logObj, {
+      columns: ctx.options.stdout.columns || 0,
+      ...ctx.options.formatOptions
+    });
+    return writeStream(
+      line + "\n",
+      logObj.level < 2 ? ctx.options.stderr || process.stderr : ctx.options.stdout || process.stdout
+    );
+  }
+};
+
+// ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/index.mjs
+import g$1 from "process";
+
+// ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/shared/consola.DXBYu-KD.mjs
+import * as tty from "tty";
+var {
+  env = {},
+  argv = [],
+  platform = ""
+} = typeof process === "undefined" ? {} : process;
+var isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+var isForced = "FORCE_COLOR" in env || argv.includes("--color");
+var isWindows = platform === "win32";
+var isDumbTerminal = env.TERM === "dumb";
+var isCompatibleTerminal = tty && tty.isatty && tty.isatty(1) && env.TERM && !isDumbTerminal;
+var isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+var isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
+function replaceClose(index, string, close, replace, head = string.slice(0, Math.max(0, index)) + replace, tail = string.slice(Math.max(0, index + close.length)), next = tail.indexOf(close)) {
+  return head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+}
+function clearBleed(index, string, open, close, replace) {
+  return index < 0 ? open + string + close : open + replaceClose(index, string, close, replace) + close;
+}
+function filterEmpty(open, close, replace = open, at = open.length + 1) {
+  return (string) => string || !(string === "" || string === void 0) ? clearBleed(
+    ("" + string).indexOf(close, at),
+    string,
+    open,
+    close,
+    replace
+  ) : "";
+}
+function init(open, close, replace) {
+  return filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, replace);
+}
+var colorDefs = {
+  reset: init(0, 0),
+  bold: init(1, 22, "\x1B[22m\x1B[1m"),
+  dim: init(2, 22, "\x1B[22m\x1B[2m"),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49)
+};
+function createColors(useColor = isColorSupported) {
+  return useColor ? colorDefs : Object.fromEntries(Object.keys(colorDefs).map((key) => [key, String]));
+}
+var colors = createColors();
+function getColor(color, fallback = "reset") {
+  return colors[color] || colors[fallback];
+}
+var ansiRegex = [
+  String.raw`[\u001B\u009B][[\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\d\/#&.:=?%@~_]+)*|[a-zA-Z\d]+(?:;[-a-zA-Z\d\/#&.:=?%@~_]*)*)?\u0007)`,
+  String.raw`(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))`
+].join("|");
+function stripAnsi(text) {
+  return text.replace(new RegExp(ansiRegex, "g"), "");
+}
+var boxStylePresets = {
+  solid: {
+    tl: "\u250C",
+    tr: "\u2510",
+    bl: "\u2514",
+    br: "\u2518",
+    h: "\u2500",
+    v: "\u2502"
+  },
+  double: {
+    tl: "\u2554",
+    tr: "\u2557",
+    bl: "\u255A",
+    br: "\u255D",
+    h: "\u2550",
+    v: "\u2551"
+  },
+  doubleSingle: {
+    tl: "\u2553",
+    tr: "\u2556",
+    bl: "\u2559",
+    br: "\u255C",
+    h: "\u2500",
+    v: "\u2551"
+  },
+  doubleSingleRounded: {
+    tl: "\u256D",
+    tr: "\u256E",
+    bl: "\u2570",
+    br: "\u256F",
+    h: "\u2500",
+    v: "\u2551"
+  },
+  singleThick: {
+    tl: "\u250F",
+    tr: "\u2513",
+    bl: "\u2517",
+    br: "\u251B",
+    h: "\u2501",
+    v: "\u2503"
+  },
+  singleDouble: {
+    tl: "\u2552",
+    tr: "\u2555",
+    bl: "\u2558",
+    br: "\u255B",
+    h: "\u2550",
+    v: "\u2502"
+  },
+  singleDoubleRounded: {
+    tl: "\u256D",
+    tr: "\u256E",
+    bl: "\u2570",
+    br: "\u256F",
+    h: "\u2550",
+    v: "\u2502"
+  },
+  rounded: {
+    tl: "\u256D",
+    tr: "\u256E",
+    bl: "\u2570",
+    br: "\u256F",
+    h: "\u2500",
+    v: "\u2502"
+  }
+};
+var defaultStyle = {
+  borderColor: "white",
+  borderStyle: "rounded",
+  valign: "center",
+  padding: 2,
+  marginLeft: 1,
+  marginTop: 1,
+  marginBottom: 1
+};
+function box(text, _opts = {}) {
+  const opts = {
+    ..._opts,
+    style: {
+      ...defaultStyle,
+      ..._opts.style
+    }
+  };
+  const textLines = text.split("\n");
+  const boxLines = [];
+  const _color = getColor(opts.style.borderColor);
+  const borderStyle = {
+    ...typeof opts.style.borderStyle === "string" ? boxStylePresets[opts.style.borderStyle] || boxStylePresets.solid : opts.style.borderStyle
+  };
+  if (_color) {
+    for (const key in borderStyle) {
+      borderStyle[key] = _color(
+        borderStyle[key]
+      );
+    }
+  }
+  const paddingOffset = opts.style.padding % 2 === 0 ? opts.style.padding : opts.style.padding + 1;
+  const height = textLines.length + paddingOffset;
+  const width = Math.max(
+    ...textLines.map((line) => stripAnsi(line).length),
+    opts.title ? stripAnsi(opts.title).length : 0
+  ) + paddingOffset;
+  const widthOffset = width + paddingOffset;
+  const leftSpace = opts.style.marginLeft > 0 ? " ".repeat(opts.style.marginLeft) : "";
+  if (opts.style.marginTop > 0) {
+    boxLines.push("".repeat(opts.style.marginTop));
+  }
+  if (opts.title) {
+    const title = _color ? _color(opts.title) : opts.title;
+    const left = borderStyle.h.repeat(
+      Math.floor((width - stripAnsi(opts.title).length) / 2)
+    );
+    const right = borderStyle.h.repeat(
+      width - stripAnsi(opts.title).length - stripAnsi(left).length + paddingOffset
+    );
+    boxLines.push(
+      `${leftSpace}${borderStyle.tl}${left}${title}${right}${borderStyle.tr}`
+    );
+  } else {
+    boxLines.push(
+      `${leftSpace}${borderStyle.tl}${borderStyle.h.repeat(widthOffset)}${borderStyle.tr}`
+    );
+  }
+  const valignOffset = opts.style.valign === "center" ? Math.floor((height - textLines.length) / 2) : opts.style.valign === "top" ? height - textLines.length - paddingOffset : height - textLines.length;
+  for (let i2 = 0; i2 < height; i2++) {
+    if (i2 < valignOffset || i2 >= valignOffset + textLines.length) {
+      boxLines.push(
+        `${leftSpace}${borderStyle.v}${" ".repeat(widthOffset)}${borderStyle.v}`
+      );
+    } else {
+      const line = textLines[i2 - valignOffset];
+      const left = " ".repeat(paddingOffset);
+      const right = " ".repeat(width - stripAnsi(line).length);
+      boxLines.push(
+        `${leftSpace}${borderStyle.v}${left}${line}${right}${borderStyle.v}`
+      );
+    }
+  }
+  boxLines.push(
+    `${leftSpace}${borderStyle.bl}${borderStyle.h.repeat(widthOffset)}${borderStyle.br}`
+  );
+  if (opts.style.marginBottom > 0) {
+    boxLines.push("".repeat(opts.style.marginBottom));
+  }
+  return boxLines.join("\n");
+}
+
+// ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/index.mjs
+import "util";
+import "path";
+import "tty";
+var r = /* @__PURE__ */ Object.create(null);
+var i = (e) => globalThis.process?.env || import.meta.env || globalThis.Deno?.env.toObject() || globalThis.__env__ || (e ? r : globalThis);
+var o = new Proxy(r, { get(e, s2) {
+  return i()[s2] ?? r[s2];
+}, has(e, s2) {
+  const E = i();
+  return s2 in E || s2 in r;
+}, set(e, s2, E) {
+  const B = i(true);
+  return B[s2] = E, true;
+}, deleteProperty(e, s2) {
+  if (!s2) return false;
+  const E = i(true);
+  return delete E[s2], true;
+}, ownKeys() {
+  const e = i(true);
+  return Object.keys(e);
+} });
+var t = typeof process < "u" && process.env && process.env.NODE_ENV || "";
+var f = [["APPVEYOR"], ["AWS_AMPLIFY", "AWS_APP_ID", { ci: true }], ["AZURE_PIPELINES", "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI"], ["AZURE_STATIC", "INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN"], ["APPCIRCLE", "AC_APPCIRCLE"], ["BAMBOO", "bamboo_planKey"], ["BITBUCKET", "BITBUCKET_COMMIT"], ["BITRISE", "BITRISE_IO"], ["BUDDY", "BUDDY_WORKSPACE_ID"], ["BUILDKITE"], ["CIRCLE", "CIRCLECI"], ["CIRRUS", "CIRRUS_CI"], ["CLOUDFLARE_PAGES", "CF_PAGES", { ci: true }], ["CODEBUILD", "CODEBUILD_BUILD_ARN"], ["CODEFRESH", "CF_BUILD_ID"], ["DRONE"], ["DRONE", "DRONE_BUILD_EVENT"], ["DSARI"], ["GITHUB_ACTIONS"], ["GITLAB", "GITLAB_CI"], ["GITLAB", "CI_MERGE_REQUEST_ID"], ["GOCD", "GO_PIPELINE_LABEL"], ["LAYERCI"], ["HUDSON", "HUDSON_URL"], ["JENKINS", "JENKINS_URL"], ["MAGNUM"], ["NETLIFY"], ["NETLIFY", "NETLIFY_LOCAL", { ci: false }], ["NEVERCODE"], ["RENDER"], ["SAIL", "SAILCI"], ["SEMAPHORE"], ["SCREWDRIVER"], ["SHIPPABLE"], ["SOLANO", "TDDIUM"], ["STRIDER"], ["TEAMCITY", "TEAMCITY_VERSION"], ["TRAVIS"], ["VERCEL", "NOW_BUILDER"], ["VERCEL", "VERCEL", { ci: false }], ["VERCEL", "VERCEL_ENV", { ci: false }], ["APPCENTER", "APPCENTER_BUILD_ID"], ["CODESANDBOX", "CODESANDBOX_SSE", { ci: false }], ["CODESANDBOX", "CODESANDBOX_HOST", { ci: false }], ["STACKBLITZ"], ["STORMKIT"], ["CLEAVR"], ["ZEABUR"], ["CODESPHERE", "CODESPHERE_APP_ID", { ci: true }], ["RAILWAY", "RAILWAY_PROJECT_ID"], ["RAILWAY", "RAILWAY_SERVICE_ID"], ["DENO-DEPLOY", "DENO_DEPLOYMENT_ID"], ["FIREBASE_APP_HOSTING", "FIREBASE_APP_HOSTING", { ci: true }]];
+function b() {
+  if (globalThis.process?.env) for (const e of f) {
+    const s2 = e[1] || e[0];
+    if (globalThis.process?.env[s2]) return { name: e[0].toLowerCase(), ...e[2] };
+  }
+  return globalThis.process?.env?.SHELL === "/bin/jsh" && globalThis.process?.versions?.webcontainer ? { name: "stackblitz", ci: false } : { name: "", ci: false };
+}
+var l = b();
+l.name;
+function n(e) {
+  return e ? e !== "false" : false;
+}
+var I = globalThis.process?.platform || "";
+var T = n(o.CI) || l.ci !== false;
+var a = n(globalThis.process?.stdout && globalThis.process?.stdout.isTTY);
+var g = n(o.DEBUG);
+var R = t === "test" || n(o.TEST);
+n(o.MINIMAL) || T || R || !a;
+var A = /^win/i.test(I);
+!n(o.NO_COLOR) && (n(o.FORCE_COLOR) || (a || A) && o.TERM !== "dumb" || T);
+var C = (globalThis.process?.versions?.node || "").replace(/^v/, "") || null;
+Number(C?.split(".")[0]) || null;
+var y = globalThis.process || /* @__PURE__ */ Object.create(null);
+var _ = { versions: {} };
+new Proxy(y, { get(e, s2) {
+  if (s2 === "env") return o;
+  if (s2 in e) return e[s2];
+  if (s2 in _) return _[s2];
+} });
+var c = globalThis.process?.release?.name === "node";
+var O = !!globalThis.Bun || !!globalThis.process?.versions?.bun;
+var D = !!globalThis.Deno;
+var L = !!globalThis.fastly;
+var S = !!globalThis.Netlify;
+var u = !!globalThis.EdgeRuntime;
+var N = globalThis.navigator?.userAgent === "Cloudflare-Workers";
+var F = [[S, "netlify"], [u, "edge-light"], [N, "workerd"], [L, "fastly"], [D, "deno"], [O, "bun"], [c, "node"]];
+function G() {
+  const e = F.find((s2) => s2[0]);
+  if (e) return { name: e[1] };
+}
+var P = G();
+P?.name || "";
+function ansiRegex2({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const pattern = [
+    `[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?${ST})`,
+    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
+  ].join("|");
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+var regex = ansiRegex2();
+function stripAnsi2(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  return string.replace(regex, "");
+}
+function isAmbiguous(x) {
+  return x === 161 || x === 164 || x === 167 || x === 168 || x === 170 || x === 173 || x === 174 || x >= 176 && x <= 180 || x >= 182 && x <= 186 || x >= 188 && x <= 191 || x === 198 || x === 208 || x === 215 || x === 216 || x >= 222 && x <= 225 || x === 230 || x >= 232 && x <= 234 || x === 236 || x === 237 || x === 240 || x === 242 || x === 243 || x >= 247 && x <= 250 || x === 252 || x === 254 || x === 257 || x === 273 || x === 275 || x === 283 || x === 294 || x === 295 || x === 299 || x >= 305 && x <= 307 || x === 312 || x >= 319 && x <= 322 || x === 324 || x >= 328 && x <= 331 || x === 333 || x === 338 || x === 339 || x === 358 || x === 359 || x === 363 || x === 462 || x === 464 || x === 466 || x === 468 || x === 470 || x === 472 || x === 474 || x === 476 || x === 593 || x === 609 || x === 708 || x === 711 || x >= 713 && x <= 715 || x === 717 || x === 720 || x >= 728 && x <= 731 || x === 733 || x === 735 || x >= 768 && x <= 879 || x >= 913 && x <= 929 || x >= 931 && x <= 937 || x >= 945 && x <= 961 || x >= 963 && x <= 969 || x === 1025 || x >= 1040 && x <= 1103 || x === 1105 || x === 8208 || x >= 8211 && x <= 8214 || x === 8216 || x === 8217 || x === 8220 || x === 8221 || x >= 8224 && x <= 8226 || x >= 8228 && x <= 8231 || x === 8240 || x === 8242 || x === 8243 || x === 8245 || x === 8251 || x === 8254 || x === 8308 || x === 8319 || x >= 8321 && x <= 8324 || x === 8364 || x === 8451 || x === 8453 || x === 8457 || x === 8467 || x === 8470 || x === 8481 || x === 8482 || x === 8486 || x === 8491 || x === 8531 || x === 8532 || x >= 8539 && x <= 8542 || x >= 8544 && x <= 8555 || x >= 8560 && x <= 8569 || x === 8585 || x >= 8592 && x <= 8601 || x === 8632 || x === 8633 || x === 8658 || x === 8660 || x === 8679 || x === 8704 || x === 8706 || x === 8707 || x === 8711 || x === 8712 || x === 8715 || x === 8719 || x === 8721 || x === 8725 || x === 8730 || x >= 8733 && x <= 8736 || x === 8739 || x === 8741 || x >= 8743 && x <= 8748 || x === 8750 || x >= 8756 && x <= 8759 || x === 8764 || x === 8765 || x === 8776 || x === 8780 || x === 8786 || x === 8800 || x === 8801 || x >= 8804 && x <= 8807 || x === 8810 || x === 8811 || x === 8814 || x === 8815 || x === 8834 || x === 8835 || x === 8838 || x === 8839 || x === 8853 || x === 8857 || x === 8869 || x === 8895 || x === 8978 || x >= 9312 && x <= 9449 || x >= 9451 && x <= 9547 || x >= 9552 && x <= 9587 || x >= 9600 && x <= 9615 || x >= 9618 && x <= 9621 || x === 9632 || x === 9633 || x >= 9635 && x <= 9641 || x === 9650 || x === 9651 || x === 9654 || x === 9655 || x === 9660 || x === 9661 || x === 9664 || x === 9665 || x >= 9670 && x <= 9672 || x === 9675 || x >= 9678 && x <= 9681 || x >= 9698 && x <= 9701 || x === 9711 || x === 9733 || x === 9734 || x === 9737 || x === 9742 || x === 9743 || x === 9756 || x === 9758 || x === 9792 || x === 9794 || x === 9824 || x === 9825 || x >= 9827 && x <= 9829 || x >= 9831 && x <= 9834 || x === 9836 || x === 9837 || x === 9839 || x === 9886 || x === 9887 || x === 9919 || x >= 9926 && x <= 9933 || x >= 9935 && x <= 9939 || x >= 9941 && x <= 9953 || x === 9955 || x === 9960 || x === 9961 || x >= 9963 && x <= 9969 || x === 9972 || x >= 9974 && x <= 9977 || x === 9979 || x === 9980 || x === 9982 || x === 9983 || x === 10045 || x >= 10102 && x <= 10111 || x >= 11094 && x <= 11097 || x >= 12872 && x <= 12879 || x >= 57344 && x <= 63743 || x >= 65024 && x <= 65039 || x === 65533 || x >= 127232 && x <= 127242 || x >= 127248 && x <= 127277 || x >= 127280 && x <= 127337 || x >= 127344 && x <= 127373 || x === 127375 || x === 127376 || x >= 127387 && x <= 127404 || x >= 917760 && x <= 917999 || x >= 983040 && x <= 1048573 || x >= 1048576 && x <= 1114109;
+}
+function isFullWidth(x) {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+}
+function isWide(x) {
+  return x >= 4352 && x <= 4447 || x === 8986 || x === 8987 || x === 9001 || x === 9002 || x >= 9193 && x <= 9196 || x === 9200 || x === 9203 || x === 9725 || x === 9726 || x === 9748 || x === 9749 || x >= 9776 && x <= 9783 || x >= 9800 && x <= 9811 || x === 9855 || x >= 9866 && x <= 9871 || x === 9875 || x === 9889 || x === 9898 || x === 9899 || x === 9917 || x === 9918 || x === 9924 || x === 9925 || x === 9934 || x === 9940 || x === 9962 || x === 9970 || x === 9971 || x === 9973 || x === 9978 || x === 9981 || x === 9989 || x === 9994 || x === 9995 || x === 10024 || x === 10060 || x === 10062 || x >= 10067 && x <= 10069 || x === 10071 || x >= 10133 && x <= 10135 || x === 10160 || x === 10175 || x === 11035 || x === 11036 || x === 11088 || x === 11093 || x >= 11904 && x <= 11929 || x >= 11931 && x <= 12019 || x >= 12032 && x <= 12245 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12353 && x <= 12438 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12773 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 42124 || x >= 42128 && x <= 42182 || x >= 43360 && x <= 43388 || x >= 44032 && x <= 55203 || x >= 63744 && x <= 64255 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 94176 && x <= 94180 || x === 94192 || x === 94193 || x >= 94208 && x <= 100343 || x >= 100352 && x <= 101589 || x >= 101631 && x <= 101640 || x >= 110576 && x <= 110579 || x >= 110581 && x <= 110587 || x === 110589 || x === 110590 || x >= 110592 && x <= 110882 || x === 110898 || x >= 110928 && x <= 110930 || x === 110933 || x >= 110948 && x <= 110951 || x >= 110960 && x <= 111355 || x >= 119552 && x <= 119638 || x >= 119648 && x <= 119670 || x === 126980 || x === 127183 || x === 127374 || x >= 127377 && x <= 127386 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x === 127568 || x === 127569 || x >= 127584 && x <= 127589 || x >= 127744 && x <= 127776 || x >= 127789 && x <= 127797 || x >= 127799 && x <= 127868 || x >= 127870 && x <= 127891 || x >= 127904 && x <= 127946 || x >= 127951 && x <= 127955 || x >= 127968 && x <= 127984 || x === 127988 || x >= 127992 && x <= 128062 || x === 128064 || x >= 128066 && x <= 128252 || x >= 128255 && x <= 128317 || x >= 128331 && x <= 128334 || x >= 128336 && x <= 128359 || x === 128378 || x === 128405 || x === 128406 || x === 128420 || x >= 128507 && x <= 128591 || x >= 128640 && x <= 128709 || x === 128716 || x >= 128720 && x <= 128722 || x >= 128725 && x <= 128727 || x >= 128732 && x <= 128735 || x === 128747 || x === 128748 || x >= 128756 && x <= 128764 || x >= 128992 && x <= 129003 || x === 129008 || x >= 129292 && x <= 129338 || x >= 129340 && x <= 129349 || x >= 129351 && x <= 129535 || x >= 129648 && x <= 129660 || x >= 129664 && x <= 129673 || x >= 129679 && x <= 129734 || x >= 129742 && x <= 129756 || x >= 129759 && x <= 129769 || x >= 129776 && x <= 129784 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+}
+function validate(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate(codePoint);
+  if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+var emojiRegex = () => {
+  return /[#*0-9]\uFE0F?\u20E3|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26AA\u26B0\u26B1\u26BD\u26BE\u26C4\u26C8\u26CF\u26D1\u26E9\u26F0-\u26F5\u26F7\u26F8\u26FA\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2757\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B55\u3030\u303D\u3297\u3299]\uFE0F?|[\u261D\u270C\u270D](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\u270A\u270B](?:\uD83C[\uDFFB-\uDFFF])?|[\u23E9-\u23EC\u23F0\u23F3\u25FD\u2693\u26A1\u26AB\u26C5\u26CE\u26D4\u26EA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2795-\u2797\u27B0\u27BF\u2B50]|\u26D3\uFE0F?(?:\u200D\uD83D\uDCA5)?|\u26F9(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\u2764\uFE0F?(?:\u200D(?:\uD83D\uDD25|\uD83E\uDE79))?|\uD83C(?:[\uDC04\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]\uFE0F?|[\uDF85\uDFC2\uDFC7](?:\uD83C[\uDFFB-\uDFFF])?|[\uDFC4\uDFCA](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDFCB\uDFCC](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF43\uDF45-\uDF4A\uDF4C-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uDDE6\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF]|\uDDE7\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF]|\uDDE8\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF7\uDDFA-\uDDFF]|\uDDE9\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF]|\uDDEA\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA]|\uDDEB\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7]|\uDDEC\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE]|\uDDED\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA]|\uDDEE\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9]|\uDDEF\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5]|\uDDF0\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF]|\uDDF1\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE]|\uDDF2\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF]|\uDDF3\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF]|\uDDF4\uD83C\uDDF2|\uDDF5\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE]|\uDDF6\uD83C\uDDE6|\uDDF7\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC]|\uDDF8\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF]|\uDDF9\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF]|\uDDFA\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF]|\uDDFB\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA]|\uDDFC\uD83C[\uDDEB\uDDF8]|\uDDFD\uD83C\uDDF0|\uDDFE\uD83C[\uDDEA\uDDF9]|\uDDFF\uD83C[\uDDE6\uDDF2\uDDFC]|\uDF44(?:\u200D\uD83D\uDFEB)?|\uDF4B(?:\u200D\uD83D\uDFE9)?|\uDFC3(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDFF3\uFE0F?(?:\u200D(?:\u26A7\uFE0F?|\uD83C\uDF08))?|\uDFF4(?:\u200D\u2620\uFE0F?|\uDB40\uDC67\uDB40\uDC62\uDB40(?:\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDC73\uDB40\uDC63\uDB40\uDC74|\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F)?)|\uD83D(?:[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3]\uFE0F?|[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC](?:\uD83C[\uDFFB-\uDFFF])?|[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4\uDEB5](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD74\uDD90](?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?|[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC25\uDC27-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE41\uDE43\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEDC-\uDEDF\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB\uDFF0]|\uDC08(?:\u200D\u2B1B)?|\uDC15(?:\u200D\uD83E\uDDBA)?|\uDC26(?:\u200D(?:\u2B1B|\uD83D\uDD25))?|\uDC3B(?:\u200D\u2744\uFE0F?)?|\uDC41\uFE0F?(?:\u200D\uD83D\uDDE8\uFE0F?)?|\uDC68(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDC68\uDC69]\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?)|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?\uDC68\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D\uDC68\uD83C[\uDFFB-\uDFFE])))?))?|\uDC69(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:\uDC8B\u200D\uD83D)?[\uDC68\uDC69]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D(?:[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?|\uDC69\u200D\uD83D(?:\uDC66(?:\u200D\uD83D\uDC66)?|\uDC67(?:\u200D\uD83D[\uDC66\uDC67])?))|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFC-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFD-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFD\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D\uD83D(?:[\uDC68\uDC69]|\uDC8B\u200D\uD83D[\uDC68\uDC69])\uD83C[\uDFFB-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83D[\uDC68\uDC69]\uD83C[\uDFFB-\uDFFE])))?))?|\uDC6F(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDD75(?:\uD83C[\uDFFB-\uDFFF]|\uFE0F)?(?:\u200D[\u2640\u2642]\uFE0F?)?|\uDE2E(?:\u200D\uD83D\uDCA8)?|\uDE35(?:\u200D\uD83D\uDCAB)?|\uDE36(?:\u200D\uD83C\uDF2B\uFE0F?)?|\uDE42(?:\u200D[\u2194\u2195]\uFE0F?)?|\uDEB6(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?)|\uD83E(?:[\uDD0C\uDD0F\uDD18-\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5\uDEC3-\uDEC5\uDEF0\uDEF2-\uDEF8](?:\uD83C[\uDFFB-\uDFFF])?|[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD\uDDCF\uDDD4\uDDD6-\uDDDD](?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDDDE\uDDDF](?:\u200D[\u2640\u2642]\uFE0F?)?|[\uDD0D\uDD0E\uDD10-\uDD17\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCC\uDDD0\uDDE0-\uDDFF\uDE70-\uDE7C\uDE80-\uDE89\uDE8F-\uDEC2\uDEC6\uDECE-\uDEDC\uDEDF-\uDEE9]|\uDD3C(?:\u200D[\u2640\u2642]\uFE0F?|\uD83C[\uDFFB-\uDFFF])?|\uDDCE(?:\uD83C[\uDFFB-\uDFFF])?(?:\u200D(?:[\u2640\u2642]\uFE0F?(?:\u200D\u27A1\uFE0F?)?|\u27A1\uFE0F?))?|\uDDD1(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1|\uDDD1\u200D\uD83E\uDDD2(?:\u200D\uD83E\uDDD2)?|\uDDD2(?:\u200D\uD83E\uDDD2)?))|\uD83C(?:\uDFFB(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFC-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFC(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFD-\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFD(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFE(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFD\uDFFF]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?|\uDFFF(?:\u200D(?:[\u2695\u2696\u2708]\uFE0F?|\u2764\uFE0F?\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1\uD83C[\uDFFB-\uDFFE]|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E(?:[\uDDAF\uDDBC\uDDBD](?:\u200D\u27A1\uFE0F?)?|[\uDDB0-\uDDB3]|\uDD1D\u200D\uD83E\uDDD1\uD83C[\uDFFB-\uDFFF])))?))?|\uDEF1(?:\uD83C(?:\uDFFB(?:\u200D\uD83E\uDEF2\uD83C[\uDFFC-\uDFFF])?|\uDFFC(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFD-\uDFFF])?|\uDFFD(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])?|\uDFFE(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFD\uDFFF])?|\uDFFF(?:\u200D\uD83E\uDEF2\uD83C[\uDFFB-\uDFFE])?))?)/g;
+};
+var segmenter = globalThis.Intl?.Segmenter ? new Intl.Segmenter() : { segment: (str) => str.split("") };
+var defaultIgnorableCodePointRegex = new RegExp("^\\p{Default_Ignorable_Code_Point}$", "u");
+function stringWidth$1(string, options = {}) {
+  if (typeof string !== "string" || string.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options;
+  if (!countAnsiEscapeCodes) {
+    string = stripAnsi2(string);
+  }
+  if (string.length === 0) {
+    return 0;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment: character } of segmenter.segment(string)) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) {
+      continue;
+    }
+    if (codePoint >= 8203 && codePoint <= 8207 || codePoint === 65279) {
+      continue;
+    }
+    if (codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071) {
+      continue;
+    }
+    if (codePoint >= 55296 && codePoint <= 57343) {
+      continue;
+    }
+    if (codePoint >= 65024 && codePoint <= 65039) {
+      continue;
+    }
+    if (defaultIgnorableCodePointRegex.test(character)) {
+      continue;
+    }
+    if (emojiRegex().test(character)) {
+      width += 2;
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+  }
+  return width;
+}
+function isUnicodeSupported() {
+  const { env: env2 } = g$1;
+  const { TERM, TERM_PROGRAM } = env2;
+  if (g$1.platform !== "win32") {
+    return TERM !== "linux";
+  }
+  return Boolean(env2.WT_SESSION) || Boolean(env2.TERMINUS_SUBLIME) || env2.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env2.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var TYPE_COLOR_MAP = {
+  info: "cyan",
+  fail: "red",
+  success: "green",
+  ready: "green",
+  start: "magenta"
+};
+var LEVEL_COLOR_MAP = {
+  0: "red",
+  1: "yellow"
+};
+var unicode = isUnicodeSupported();
+var s = (c2, fallback) => unicode ? c2 : fallback;
+var TYPE_ICONS = {
+  error: s("\u2716", "\xD7"),
+  fatal: s("\u2716", "\xD7"),
+  ready: s("\u2714", "\u221A"),
+  warn: s("\u26A0", "\u203C"),
+  info: s("\u2139", "i"),
+  success: s("\u2714", "\u221A"),
+  debug: s("\u2699", "D"),
+  trace: s("\u2192", "\u2192"),
+  fail: s("\u2716", "\xD7"),
+  start: s("\u25D0", "o"),
+  log: ""
+};
+function stringWidth(str) {
+  const hasICU = typeof Intl === "object";
+  if (!hasICU || !Intl.Segmenter) {
+    return stripAnsi(str).length;
+  }
+  return stringWidth$1(str);
+}
+var FancyReporter = class extends BasicReporter {
+  formatStack(stack, message, opts) {
+    const indent = "  ".repeat((opts?.errorLevel || 0) + 1);
+    return `
+${indent}` + parseStack(stack, message).map(
+      (line) => "  " + line.replace(/^at +/, (m) => colors.gray(m)).replace(/\((.+)\)/, (_2, m) => `(${colors.cyan(m)})`)
+    ).join(`
+${indent}`);
+  }
+  formatType(logObj, isBadge, opts) {
+    const typeColor = TYPE_COLOR_MAP[logObj.type] || LEVEL_COLOR_MAP[logObj.level] || "gray";
+    if (isBadge) {
+      return getBgColor(typeColor)(
+        colors.black(` ${logObj.type.toUpperCase()} `)
+      );
+    }
+    const _type = typeof TYPE_ICONS[logObj.type] === "string" ? TYPE_ICONS[logObj.type] : logObj.icon || logObj.type;
+    return _type ? getColor2(typeColor)(_type) : "";
+  }
+  formatLogObj(logObj, opts) {
+    const [message, ...additional] = this.formatArgs(logObj.args, opts).split(
+      "\n"
+    );
+    if (logObj.type === "box") {
+      return box(
+        characterFormat(
+          message + (additional.length > 0 ? "\n" + additional.join("\n") : "")
+        ),
+        {
+          title: logObj.title ? characterFormat(logObj.title) : void 0,
+          style: logObj.style
+        }
+      );
+    }
+    const date = this.formatDate(logObj.date, opts);
+    const coloredDate = date && colors.gray(date);
+    const isBadge = logObj.badge ?? logObj.level < 2;
+    const type = this.formatType(logObj, isBadge, opts);
+    const tag = logObj.tag ? colors.gray(logObj.tag) : "";
+    let line;
+    const left = this.filterAndJoin([type, characterFormat(message)]);
+    const right = this.filterAndJoin(opts.columns ? [tag, coloredDate] : [tag]);
+    const space = (opts.columns || 0) - stringWidth(left) - stringWidth(right) - 2;
+    line = space > 0 && (opts.columns || 0) >= 80 ? left + " ".repeat(space) + right : (right ? `${colors.gray(`[${right}]`)} ` : "") + left;
+    line += characterFormat(
+      additional.length > 0 ? "\n" + additional.join("\n") : ""
+    );
+    if (logObj.type === "trace") {
+      const _err = new Error("Trace: " + logObj.message);
+      line += this.formatStack(_err.stack || "", _err.message);
+    }
+    return isBadge ? "\n" + line + "\n" : line;
+  }
+};
+function characterFormat(str) {
+  return str.replace(/`([^`]+)`/gm, (_2, m) => colors.cyan(m)).replace(/\s+_([^_]+)_\s+/gm, (_2, m) => ` ${colors.underline(m)} `);
+}
+function getColor2(color = "white") {
+  return colors[color] || colors.white;
+}
+function getBgColor(color = "bgWhite") {
+  return colors[`bg${color[0].toUpperCase()}${color.slice(1)}`] || colors.bgWhite;
+}
+function createConsola2(options = {}) {
+  let level = _getDefaultLogLevel();
+  if (process.env.CONSOLA_LEVEL) {
+    level = Number.parseInt(process.env.CONSOLA_LEVEL) ?? level;
+  }
+  const consola2 = createConsola({
+    level,
+    defaults: { level },
+    stdout: process.stdout,
+    stderr: process.stderr,
+    prompt: (...args) => import("./prompt-GMZABCJC.js").then((m) => m.prompt(...args)),
+    reporters: options.reporters || [
+      options.fancy ?? !(T || R) ? new FancyReporter() : new BasicReporter()
+    ],
+    ...options
+  });
+  return consola2;
+}
+function _getDefaultLogLevel() {
+  if (g) {
+    return LogLevels.debug;
+  }
+  if (R) {
+    return LogLevels.warn;
+  }
+  return LogLevels.info;
+}
+var consola = createConsola2();
+
+// ../../packages/api-client/src/core/bodySerializer.gen.ts
+var jsonBodySerializer = {
+  bodySerializer: (body) => JSON.stringify(
+    body,
+    (_key, value) => typeof value === "bigint" ? value.toString() : value
+  )
+};
+
+// ../../packages/api-client/src/core/params.gen.ts
+var extraPrefixesMap = {
+  $body_: "body",
+  $headers_: "headers",
+  $path_: "path",
+  $query_: "query"
+};
+var extraPrefixes = Object.entries(extraPrefixesMap);
+
+// ../../packages/api-client/src/core/serverSentEvents.gen.ts
+var createSseClient = ({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}) => {
+  let lastEventId;
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3e3;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted) break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== void 0) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
+        }
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok)
+          throw new Error(
+            `SSE failed: ${response.status} ${response.statusText}`
+          );
+        if (!response.body) throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {
+          }
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += value;
+            const chunks = buffer.split("\r\n");
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split("\n");
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(
+                    line.replace(/^retry:\s*/, ""),
+                    10
+                  );
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join("\n");
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(
+          retryDelay * 2 ** (attempt - 1),
+          sseMaxRetryDelay ?? 3e4
+        );
+        await sleep(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+};
+
+// ../../packages/api-client/src/core/pathSerializer.gen.ts
+var separatorArrayExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var separatorArrayNoExplode = (style) => {
+  switch (style) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+};
+var separatorObjectExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value
+}) => {
+  if (!explode) {
+    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      case "simple":
+        return joinedValues2;
+      default:
+        return `${name}=${joinedValues2}`;
+    }
+  }
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value.map((v) => {
+    if (style === "label" || style === "simple") {
+      return allowReserved ? v : encodeURIComponent(v);
+    }
+    return serializePrimitiveParam({
+      allowReserved,
+      name,
+      value: v
+    });
+  }).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+var serializePrimitiveParam = ({
+  allowReserved,
+  name,
+  value
+}) => {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+var serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+  if (style !== "deepObject" && !explode) {
+    let values = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values = [
+        ...values,
+        key,
+        allowReserved ? v : encodeURIComponent(v)
+      ];
+    });
+    const joinedValues2 = values.join(",");
+    switch (style) {
+      case "form":
+        return `${name}=${joinedValues2}`;
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      default:
+        return joinedValues2;
+    }
+  }
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value).map(
+    ([key, v]) => serializePrimitiveParam({
+      allowReserved,
+      name: style === "deepObject" ? `${name}[${key}]` : key,
+      value: v
+    })
+  ).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+// ../../packages/api-client/src/core/utils.gen.ts
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var defaultPathSerializer = ({ path: path3, url: _url }) => {
+  let url = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name = match.substring(1, match.length - 1);
+      let style = "simple";
+      if (name.endsWith("*")) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+      if (name.startsWith(".")) {
+        name = name.substring(1);
+        style = "label";
+      } else if (name.startsWith(";")) {
+        name = name.substring(1);
+        style = "matrix";
+      }
+      const value = path3[name];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url = url.replace(
+          match,
+          serializeArrayParam({ explode, name, style, value })
+        );
+        continue;
+      }
+      if (typeof value === "object") {
+        url = url.replace(
+          match,
+          serializeObjectParam({
+            explode,
+            name,
+            style,
+            value,
+            valueOnly: true
+          })
+        );
+        continue;
+      }
+      if (style === "matrix") {
+        url = url.replace(
+          match,
+          `;${serializePrimitiveParam({
+            name,
+            value
+          })}`
+        );
+        continue;
+      }
+      const replaceValue = encodeURIComponent(
+        style === "label" ? `.${value}` : value
+      );
+      url = url.replace(match, replaceValue);
+    }
+  }
+  return url;
+};
+var getUrl = ({
+  baseUrl,
+  path: path3,
+  query,
+  querySerializer,
+  url: _url
+}) => {
+  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+  let url = (baseUrl ?? "") + pathUrl;
+  if (path3) {
+    url = defaultPathSerializer({ path: path3, url });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url += `?${search}`;
+  }
+  return url;
+};
+function getValidRequestBody(options) {
+  const hasBody = options.body !== void 0;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return void 0;
+}
+
+// ../../packages/api-client/src/core/auth.gen.ts
+var getAuthToken = async (auth, callback) => {
+  const token = typeof callback === "function" ? await callback(auth) : callback;
+  if (!token) {
+    return;
+  }
+  if (auth.scheme === "bearer") {
+    return `Bearer ${token}`;
+  }
+  if (auth.scheme === "basic") {
+    return `Basic ${btoa(token)}`;
+  }
+  return token;
+};
+
+// ../../packages/api-client/src/client/utils.gen.ts
+var createQuerySerializer = ({
+  parameters = {},
+  ...args
+} = {}) => {
+  const querySerializer = (queryParams) => {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        const options = parameters[name] || args;
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "form",
+            value,
+            ...options.array
+          });
+          if (serializedArray) search.push(serializedArray);
+        } else if (typeof value === "object") {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "deepObject",
+            value,
+            ...options.object
+          });
+          if (serializedObject) search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name,
+            value
+          });
+          if (serializedPrimitive) search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join("&");
+  };
+  return querySerializer;
+};
+var getParseAs = (contentType) => {
+  if (!contentType) {
+    return "stream";
+  }
+  const cleanContent = contentType.split(";")[0]?.trim();
+  if (!cleanContent) {
+    return;
+  }
+  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+    return "json";
+  }
+  if (cleanContent === "multipart/form-data") {
+    return "formData";
+  }
+  if (["application/", "audio/", "image/", "video/"].some(
+    (type) => cleanContent.startsWith(type)
+  )) {
+    return "blob";
+  }
+  if (cleanContent.startsWith("text/")) {
+    return "text";
+  }
+  return;
+};
+var checkForExistence = (options, name) => {
+  if (!name) {
+    return false;
+  }
+  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+    return true;
+  }
+  return false;
+};
+var setAuthParams = async ({
+  security,
+  ...options
+}) => {
+  for (const auth of security) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+    const token = await getAuthToken(auth, options.auth);
+    if (!token) {
+      continue;
+    }
+    const name = auth.name ?? "Authorization";
+    switch (auth.in) {
+      case "query":
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name] = token;
+        break;
+      case "cookie":
+        options.headers.append("Cookie", `${name}=${token}`);
+        break;
+      case "header":
+      default:
+        options.headers.set(name, token);
+        break;
+    }
+  }
+};
+var buildUrl = (options) => getUrl({
+  baseUrl: options.baseUrl,
+  path: options.path,
+  query: options.query,
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+  url: options.url
+});
+var mergeConfigs = (a2, b2) => {
+  const config = { ...a2, ...b2 };
+  if (config.baseUrl?.endsWith("/")) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a2.headers, b2.headers);
+  return config;
+};
+var headersEntries = (headers) => {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+};
+var mergeHeaders = (...headers) => {
+  const mergedHeaders = new Headers();
+  for (const header of headers) {
+    if (!header) {
+      continue;
+    }
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v);
+        }
+      } else if (value !== void 0) {
+        mergedHeaders.set(
+          key,
+          typeof value === "object" ? JSON.stringify(value) : value
+        );
+      }
+    }
+  }
+  return mergedHeaders;
+};
+var Interceptors = class {
+  fns = [];
+  clear() {
+    this.fns = [];
+  }
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
+    }
+  }
+  exists(id) {
+    const index = this.getInterceptorIndex(id);
+    return Boolean(this.fns[index]);
+  }
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this.fns[id] ? id : -1;
+    }
+    return this.fns.indexOf(id);
+  }
+  update(id, fn) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = fn;
+      return id;
+    }
+    return false;
+  }
+  use(fn) {
+    this.fns.push(fn);
+    return this.fns.length - 1;
+  }
+};
+var createInterceptors = () => ({
+  error: new Interceptors(),
+  request: new Interceptors(),
+  response: new Interceptors()
+});
+var defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: "form"
+  },
+  object: {
+    explode: true,
+    style: "deepObject"
+  }
+});
+var defaultHeaders = {
+  "Content-Type": "application/json"
+};
+var createConfig = (override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: "auto",
+  querySerializer: defaultQuerySerializer,
+  ...override
+});
+
+// ../../packages/api-client/src/client/client.gen.ts
+var createClient = (config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
+  const getConfig = () => ({ ..._config });
+  const setConfig = (config2) => {
+    _config = mergeConfigs(_config, config2);
+    return getConfig();
+  };
+  const interceptors = createInterceptors();
+  const beforeRequest = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: void 0
+    };
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security
+      });
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body !== void 0 && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.body === void 0 || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const url = buildUrl(opts);
+    return { opts, url };
+  };
+  const request = async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    const requestInit = {
+      redirect: "follow",
+      ...opts,
+      body: getValidRequestBody(opts)
+    };
+    let request2 = new Request(url, requestInit);
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        request2 = await fn(request2, opts);
+      }
+    }
+    const _fetch = opts.fetch;
+    let response;
+    try {
+      response = await _fetch(request2);
+    } catch (error2) {
+      let finalError2 = error2;
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError2 = await fn(
+            error2,
+            void 0,
+            request2,
+            opts
+          );
+        }
+      }
+      finalError2 = finalError2 || {};
+      if (opts.throwOnError) {
+        throw finalError2;
+      }
+      return opts.responseStyle === "data" ? void 0 : {
+        error: finalError2,
+        request: request2,
+        response: void 0
+      };
+    }
+    for (const fn of interceptors.response.fns) {
+      if (fn) {
+        response = await fn(response, request2, opts);
+      }
+    }
+    const result = {
+      request: request2,
+      response
+    };
+    if (response.ok) {
+      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        let emptyData;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "text":
+            emptyData = await response[parseAs]();
+            break;
+          case "formData":
+            emptyData = new FormData();
+            break;
+          case "stream":
+            emptyData = response.body;
+            break;
+          case "json":
+          default:
+            emptyData = {};
+            break;
+        }
+        return opts.responseStyle === "data" ? emptyData : {
+          data: emptyData,
+          ...result
+        };
+      }
+      let data;
+      switch (parseAs) {
+        case "arrayBuffer":
+        case "blob":
+        case "formData":
+        case "json":
+        case "text":
+          data = await response[parseAs]();
+          break;
+        case "stream":
+          return opts.responseStyle === "data" ? response.body : {
+            data: response.body,
+            ...result
+          };
+      }
+      if (parseAs === "json") {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+      return opts.responseStyle === "data" ? data : {
+        data,
+        ...result
+      };
+    }
+    const textError = await response.text();
+    let jsonError;
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {
+    }
+    const error = jsonError ?? textError;
+    let finalError = error;
+    for (const fn of interceptors.error.fns) {
+      if (fn) {
+        finalError = await fn(error, response, request2, opts);
+      }
+    }
+    finalError = finalError || {};
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+    return opts.responseStyle === "data" ? void 0 : {
+      error: finalError,
+      ...result
+    };
+  };
+  const makeMethodFn = (method) => (options) => request({ ...options, method });
+  const makeSseFn = (method) => async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      headers: opts.headers,
+      method,
+      onRequest: async (url2, init2) => {
+        let request2 = new Request(url2, init2);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request2 = await fn(request2, opts);
+          }
+        }
+        return request2;
+      },
+      serializedBody: getValidRequestBody(opts),
+      url
+    });
+  };
+  return {
+    buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE")
+    },
+    trace: makeMethodFn("TRACE")
+  };
+};
+
+// ../../packages/api-client/src/client.gen.ts
+var client = createClient(createConfig({ baseUrl: "https://dreamboard.games" }));
+
+// src/utils/fs.ts
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import path from "path";
+
+// src/generated/skill-content.generated.ts
+var SKILL_ASSET_FILES = {
+  "references/adversarial-testing.md": "# Adversarial Testing\n\nAdversarial testing uses scenario files to intentionally stress game rules, turn gating, and edge conditions.\n\nUse this guide with `dreamboard run --scenario <file>`.\n\nThis file is about adversarial coverage strategy, not JSON schema.\n\n- For the JSON step format itself, see [scenario-format.md](scenario-format.md).\n- For TypeScript regression tests, see [test-harness.md](test-harness.md).\n\n## Goals\n\n1. Validate that illegal or out-of-sequence actions are rejected.\n2. Validate that legal actions still work after edge-state pressure.\n3. Catch flaky behavior by running with deterministic seeds.\n\n## Core Workflow\n\n1. Start from a known state:\n\n```bash\ndreamboard run --new-session --seed 1337 --players <playerCount>\n```\n\n2. Inspect `.dreamboard/run/latest-your-turn.json` to identify:\n\n   - Current controllable player(s)\n   - Available actions and parameter shapes\n   - Turn/phase context\n\n3. Write a focused scenario file that targets one adversarial behavior.\n4. Execute the scenario:\n\n```bash\ndreamboard run --players <playerCount> --scenario scenario-for-<case>.json\n```\n\n5. Validate outcomes using:\n   - CLI exit result (`scenario_completed` vs `scenario_rejected`)\n   - `.dreamboard/run/events.ndjson`\n   - `.dreamboard/run/last-run-summary.json`\n\nFor deeper inspection, extract specific fields from events:\n\n```bash\nnode .agents/skills/dreamboard/scripts/events-extract.mjs --type ACTION_REJECTED --field message.reason\nnode .agents/skills/dreamboard/scripts/events-extract.mjs --type YOUR_TURN --field message.availableActions --limit 1\n```\n\n## Progression Strategy\n\n1. Start simple first:\n   - Begin with 1-step or 2-step scenarios.\n   - Use a single player (`player-1`) and one expected behavior per file.\n   - Confirm your action names and parameter shapes are correct before scaling up.\n2. Then move to complex simulations:\n   - Create multi-step scenarios that chain several turns.\n   - Include multiple players across steps (for example `player-1`, `player-2`, `player-3`).\n   - Combine normal and adversarial actions in the same flow to test resilience after state transitions.\n3. Create scenario that fully tests a round (e.g. all players played their hand, or all players placed their workers)\n4. Ensure AUTO phase transitions are correct.\n5. Keep deterministic inputs (`--new-session --seed 1337`) while increasing complexity so failures stay reproducible.\n\nBuild scenario files using the contract in [scenario-format.md](scenario-format.md), then use the patterns below to decide what to test.\n\n## Adversarial Patterns\n\nCreate one scenario per pattern so failures are easy to triage.\n\n1. Invalid parameters: missing required input, invalid enum, or out-of-range values.\n2. Wrong player: action submitted by a non-active/non-controllable player.\n3. Order violation: execute actions in a sequence that should be illegal.\n4. Resource exhaustion: repeat actions until resources/cards/slots are depleted.\n5. Duplicate or replay behavior: attempt the same step repeatedly in one turn.\n6. Boundary transitions: move through end-of-round/end-of-game boundaries and attempt one extra action.\n\n## Practical Conventions\n\n1. Keep each scenario small and single-purpose.\n2. Name files by expected behavior, for example:\n   - `scenario-reject-invalid-params.json`\n   - `scenario-reject-wrong-player.json`\n   - `scenario-endgame-boundary.json`\n3. Prefer `--new-session --seed 1337` while authoring/debugging to avoid random drift.\n4. If turn context is missing, `dreamboard run --scenario ...` will wait for the first `YOUR_TURN` automatically.\n5. API scenarios are strict: if a step gets `ACTION_REJECTED`, the run stops with `scenario_rejected`.\n6. Use `events-extract.ts` to quickly inspect rejection reasons, available actions, and player transitions before editing scenarios.\n\n### Error: `Card is not in your hand`\n\nWhen this rejection appears, verify the target player's hand state across turns before and after each scenario step.\n\n1. Extract rejection events first:\n\n```bash\nnode .agents/skills/dreamboard/scripts/events-extract.mjs --type ACTION_REJECTED --field message.reason\n```\n\n2. Inspect hand snapshots from turn events for the target player (example: `player-2`):\n\n```bash\nnode .agents/skills/dreamboard/scripts/events-extract.mjs --type YOUR_TURN --player player-2 --field message.gameState.hands\n```\n\n3. Compare entries by `index` in output to see how the player's hand changes between turns.\n4. Confirm the `cardId` in your scenario step exists in the target player's hand at the turn where the action is submitted.\n5. If the card disappears earlier than expected, inspect preceding steps for draws/discards/transfers that changed ownership.\n\n## Optional UI Driver\n\nUse `--scenario-driver ui` only for browser input-path coverage (click targets, interaction wiring).\nKeep most adversarial rule tests on the API driver for reliability and speed.\n",
+  "references/all-players-tracking.md": '# ALL_PLAYERS Phase - Tracking Who Has Acted\n\nThe engine automatically tracks action progress in `ALL_PLAYERS` (`MultiplePlayer`) phases through `ctx.phase`. Do not implement manual KV tracking for this.\n\n## Built-in phase tracking API\n\nUse `ctx.phase` in `validateAction` and `checkCompletion`:\n\n- `ctx.phase.hasPlayerActed(playerId)` - has this player already submitted an action?\n- `ctx.phase.haveAllExpectedPlayersActed()` - are all currently expected players done?\n- `ctx.phase.getPlayersStillWaiting()` - which players are still pending?\n- `ctx.phase.getExpectedPlayers()` - who is expected to act this phase?\n- `ctx.phase.getPlayersWhoActed()` - who has already acted?\n\n## Recommended pattern\n\n```typescript\nimport type { MultiplePlayerPhaseDefinition } from "../sdk/phaseHandlers";\nimport { createMultiplePlayerPhase } from "../sdk/phaseHandlers";\nimport { validationSuccess, validationError } from "../sdk/validation.js";\n\ntype PhaseAction = "revealCard";\n\nconst phaseDefinition = {\n  onEnter(ctx) {\n    const { state, apis } = ctx;\n    apis.gameApi.setActivePlayers(state.player.getOrder());\n    // No manual tracking setup required.\n  },\n\n  validateAction(ctx, playerId, actionType, parameters) {\n    if (ctx.phase.hasPlayerActed(playerId)) {\n      return validationError("already-acted", "You already acted this phase");\n    }\n    return validationSuccess();\n  },\n\n  onPlayerAction(ctx, playerId, actionType, parameters) {\n    const { apis } = ctx;\n    // ... process action ...\n    // Engine tracking updates automatically after accepted actions.\n  },\n\n  checkCompletion(ctx) {\n    if (ctx.phase.haveAllExpectedPlayersActed()) {\n      return "nextPhase";\n    }\n    return null;\n  },\n\n  onComplete(ctx) {\n    // Optional cleanup only. No action-tracking cleanup required.\n  },\n\n  getUIArgs(ctx, playerId) {\n    return {\n      waitingOn: ctx.phase.getPlayersStillWaiting(),\n    };\n  },\n} satisfies MultiplePlayerPhaseDefinition<"revealCards", PhaseAction>;\n\nexport const phase = createMultiplePlayerPhase(phaseDefinition);\n```\n\n## If UI needs progress data\n\n`ctx.phase` is available in app logic. For UI, pass derived values via `getUIArgs()` (for example `waitingOn`), or write explicit UI-facing values via global/player state APIs.\n\n## Checklist for ALL_PLAYERS phases\n\n1. Call `apis.gameApi.setActivePlayers(state.player.getOrder())` in `onEnter`.\n2. Block duplicate actions with `ctx.phase.hasPlayerActed(playerId)` in `validateAction`.\n3. Process each action in `onPlayerAction` without manual tracking writes.\n4. Transition from `checkCompletion` when `ctx.phase.haveAllExpectedPlayersActed()` is true.\n5. Use `ctx.phase.getPlayersStillWaiting()` / `getPlayersWhoActed()` for logs or UI args as needed.\n',
+  "references/api-reference.md": '# State & API Reference\n\n## Read APIs (`ctx.state.*`)\n\n### `state.player`\n\n| Method                                 | Returns       | Description                           |\n| -------------------------------------- | ------------- | ------------------------------------- |\n| `.getOrder()`                          | `PlayerId[]`  | All players in turn order             |\n| `.getCurrentIds()`                     | `PlayerId[]`  | Currently active player IDs           |\n| `.get(playerId)`                       | `Player`      | Player data: `{ id, name, score }`    |\n| `.getState(playerId)`                  | `PlayerState` | Player variables from manifest schema |\n| `.getHand(playerId, handId)`           | `CardId[]`    | Cards in a specific hand              |\n| `.getAllHands(playerId)`               | `CardId[]`    | All cards across all hands            |\n| `.isInHand(playerId, cardId, handId?)` | `boolean`     | Check if card is in hand              |\n| `.isActive(playerId)`                  | `boolean`     | Is player currently active            |\n\n### `state.deck`\n\n| Method                | Returns          | Description            |\n| --------------------- | ---------------- | ---------------------- |\n| `.getCards(deckId)`   | `CardId[]`       | Cards in a shared deck |\n| `.getTopCard(deckId)` | `CardId \\| null` | Top card of deck       |\n\n### `state.card`\n\n| Method                           | Returns            | Description                                          |\n| -------------------------------- | ------------------ | ---------------------------------------------------- |\n| `.get(cardId)`                   | `Card`             | Full card data                                       |\n| `.getProperties(cardId)`         | Typed properties   | Card-specific props (rank, suit, etc.)               |\n| `.getLocation(cardId)`           | `Location`         | Where the card is (InHand, InDeck, InZone, Detached) |\n| `.getPlayedBy(cardId)`           | `PlayerId \\| null` | Who played this card to a deck/zone                  |\n| `.getOwner(cardId)`              | `PlayerId \\| null` | Card owner                                           |\n| `.isVisibleTo(cardId, playerId)` | `boolean`          | Visibility check                                     |\n| `.getOwnedBy(playerId)`          | `CardId[]`         | All cards owned by player                            |\n\n### `state.game`\n\n| Method               | Returns       | Description                           |\n| -------------------- | ------------- | ------------------------------------- |\n| `.getGlobalState()`  | `GlobalState` | Global variables from manifest schema |\n| `.getCurrentState()` | `StateName`   | Current state machine state           |\n\n## Mutation APIs (`ctx.apis.*`)\n\n### `apis.cardApi`\n\n| Method                                                                      | Description                    |\n| --------------------------------------------------------------------------- | ------------------------------ |\n| `.moveCardsFromHandToDeck(playerId, handId, cardIds, deckId)`               | Hand \u2192 Deck                    |\n| `.moveCardsFromHandToHand(fromPlayer, fromHand, toPlayer, toHand, cardIds)` | Hand \u2192 Hand                    |\n| `.moveCardsToPlayer(cardIds, toPlayerId, handId)`                           | Any \u2192 Hand                     |\n| `.flip(deckId, cardId)`                                                     | Flip card face up/down         |\n| `.detachCard(cardId)`                                                       | Remove card from all locations |\n| `.transferOwnership(cardId, toPlayer)`                                      | Change card owner              |\n\n#### Card movement semantics\n\n- `moveCardsFromHandToHand(fromPlayer, fromHand, toPlayer, toHand, cardIds)` is **additive** at destination.\n- Destination cards are preserved; moved cards are added to the destination hand.\n- This API does **not** replace/overwrite the destination hand.\n- For pass/rotate mechanics where each player should receive exactly one other player\'s hand, avoid in-place cyclic moves. Snapshot source hands first, then move via a temporary location (or other two-phase transfer pattern).\n\n### `apis.deckApi`\n\n| Method                                                        | Description               |\n| ------------------------------------------------------------- | ------------------------- |\n| `.moveCardsFromDeckToPlayer(deckId, playerId, handId, count)` | Deck \u2192 Hand (deal)        |\n| `.moveCardsFromDeckToDeck(fromDeckId, toDeckId)`              | Deck \u2192 Deck               |\n| `.shuffle(deckId)`                                            | Shuffle a deck            |\n| `.addCards(deckId, cardIds)`                                  | Add cards to a deck       |\n| `.removeCard(deckId, cardId)`                                 | Remove a card from a deck |\n\n### `apis.gameApi`\n\n| Method                             | Description                                    |\n| ---------------------------------- | ---------------------------------------------- |\n| `.setActivePlayers(playerIds)`     | Set who can act (use in ALL_PLAYERS `onEnter`) |\n| `.setNextPlayer(playerId)`         | Set single active player                       |\n| `.advanceTurn()`                   | Move to next player in order                   |\n| `.declareWinner(playerId, reason)` | Declare game winner                            |\n| `.endGame()`                       | End the game                                   |\n\n### `apis.globalStateApi`\n\n| Method                                | Description                  |\n| ------------------------------------- | ---------------------------- |\n| `.setGlobalState(newState)`           | Replace all global variables |\n| `.setPlayerState(playerId, newState)` | Replace a player\'s variables |\n\n### `apis.kvApi`\n\nInternal-only key-value store. **UI cannot access these values.**\n\n| Method             | Returns          | Description                         |\n| ------------------ | ---------------- | ----------------------------------- |\n| `.set(key, value)` | `KvSetResult`    | Store a JSON value                  |\n| `.get(key)`        | `KvGetResult`    | Read a value (`.success`, `.value`) |\n| `.delete(key)`     | `KvDeleteResult` | Remove a key                        |\n| `.has(key)`        | `boolean`        | Check existence                     |\n| `.keys()`          | `string[]`       | List all keys                       |\n\n### `apis.resourceApi`\n\n| Method                    | Description                |\n| ------------------------- | -------------------------- |\n| `.add(playerId, cost)`    | Give resources to player   |\n| `.deduct(playerId, cost)` | Take resources from player |\n\n### `apis.dieApi`\n\n| Method                     | Description               |\n| -------------------------- | ------------------------- |\n| `.roll(dieId)`             | Roll a die                |\n| `.setValue(dieId, value?)` | Set die to specific value |\n\n## Typed KV Store\n\nUse `createTypedKv` from `sdk/stateApi.js` for type-safe KV access:\n\n```typescript\nimport { createTypedKv } from "../sdk/stateApi.js";\n\ninterface MyKv {\n  playersActed: PlayerId[];\n  roundData: { scores: number[] };\n}\n\nconst kv = createTypedKv<MyKv>(apis.kvApi);\nkv.set("playersActed", ["player-1"]); // Type-checked key and value\nconst acted = kv.get("playersActed"); // PlayerId[] | null\nkv.has("playersActed"); // boolean\nkv.delete("playersActed"); // boolean (existed)\n```\n\n## Card `playedBy` Tracking\n\nWhen cards move from a Hand to a Deck via `moveCardsFromHandToDeck()`, the engine automatically records `playedBy` on each card:\n\n```typescript\n// Move card from player\'s hand to a shared deck\napis.cardApi.moveCardsFromHandToDeck(\n  playerId,\n  "main-hand",\n  [cardId],\n  "play-area",\n);\n\n// Later, check who played a specific card\nconst whoPlayed = state.card.getPlayedBy(cardId); // PlayerId | null\n```\n\n## Location Type\n\nCards have a location discriminated union:\n\n```typescript\ntype Location =\n  | { type: "Detached" }\n  | {\n      type: "InDeck";\n      deckId: DeckId;\n      playedBy: PlayerId | null;\n      position: number | null;\n    }\n  | {\n      type: "InHand";\n      handId: HandId;\n      playerId: PlayerId;\n      position: number | null;\n    }\n  | {\n      type: "InZone";\n      zoneId: string;\n      playedBy: PlayerId | null;\n      position: number | null;\n    };\n```\n\n## Validation Helpers\n\n```typescript\nimport { validationSuccess, validationError } from "../sdk/validation.js";\n\n// Valid action\nreturn validationSuccess();\n\n// Invalid action \u2014 errorCode should be kebab-case\nreturn validationError(\n  "must-play-valid-combination",\n  "You must play a valid card combination",\n);\n```\n',
+  "references/app-best-practices.md": '# App Best Practices\n\nBest practices for working on `app/phases/*.ts` \u2014 the server-side game logic.\n\n## Before writing any code\n\n1. **Read the manifest** \u2014 understand all decks, hands, zones, resources, state machine states, and card types from `shared/manifest.d.ts`.\n2. **Read all existing phases** \u2014 read every file in `app/phases/` to understand the current flow.\n3. **Read the types** \u2014 review `app/sdk/types.d.ts`, `app/sdk/phaseHandlers.ts`, and `app/sdk/state.d.ts` for the full API surface.\n\n## Core principles\n\n1. **Authoritative script** \u2014 the app script is the source of truth for a multiplayer game. All mutations must go through APIs; never assume the UI tracks state.\n2. **Optimistic results** \u2014 use the data returned by mutation APIs within the same transaction. `state.*` reads may be stale until the next call.\n3. **Active vs next players** \u2014 use `setActivePlayers()` for simultaneous phases (ALL_PLAYERS); use `setNextPlayer()` for turn-based phases (SINGLE_PLAYER).\n4. **Card movement guardrail** \u2014 every card location change must use a move API. Never assume the UI or staging moved cards.\n5. **Manifest alignment** \u2014 use deck/hand/zone IDs exactly as defined in `shared/manifest.d.ts`. Do not invent new identifiers.\n6. **KV is internal** \u2014 `kvApi` is invisible to the UI. Pass data to UI via `getUIArgs()`, `globalStateApi`, or `playerStateApi`.\n7. **Preserve player-visible outcomes** \u2014 if an AUTO phase resolves a round or a reveal, keep the round-result information in state long enough for the next player-visible phase to render it.\n\n## Validation\n\n- Always implement `validateAction` for SINGLE_PLAYER and ALL_PLAYERS phases.\n- Return `validationSuccess()` for valid actions.\n- Return `validationError(code, message)` for invalid actions. Codes should be kebab-case (e.g., `\'must-play-valid-combination\'`).\n\n## UIArgs contract\n\n- Define UIArgs interfaces in `shared/ui-args.ts` to specify what data flows from app to UI.\n- Implement `getUIArgs(ctx, playerId)` in each player-facing phase to return the data the UI needs.\n- UIArgs should be minimal \u2014 only pass what the UI actually uses.\n- Avoid passing raw card IDs when you can pass computed values (e.g., `canPlayCard: boolean` instead of making the UI recompute).\n\n## Array and type safety\n\n- Check array length before indexing. Never assume arrays are non-empty.\n- Use guards from `app/generated/guards.ts` via `../generated/guards` for ID type assertions.\n- Never cast to `any` \u2014 always work with the generated types.\n\n## Logging\n\n- Log key actions with concise payloads (IDs and counts), not full arrays.\n- Use `ctx.logger` for structured logging.\n\n## Common patterns\n\n### Typed KV store\n\n```typescript\nimport { createTypedKv } from "../sdk/stateApi.js";\n\ninterface PhaseKv {\n  playersActed: PlayerId[];\n  roundNumber: number;\n}\n\nconst kv = createTypedKv<PhaseKv>(apis.kvApi);\nkv.set("playersActed", []);\nconst acted = kv.get("playersActed"); // PlayerId[] | null\n```\n\n### Card playedBy tracking\n\n```typescript\n// Cards moved via moveCardsFromHandToDeck automatically track playedBy\napis.cardApi.moveCardsFromHandToDeck(\n  playerId,\n  "main-hand",\n  [cardId],\n  "play-area",\n);\nconst whoPlayed = state.card.getPlayedBy(cardId); // PlayerId | null\n```\n\n### Turn advancement\n\n```typescript\n// In onAfterAction for SINGLE_PLAYER phases\nonAfterAction(ctx, playerId, actionType) {\n  ctx.apis.gameApi.advanceTurn();\n},\n```\n\n### ALL_PLAYERS tracking\n\nSee [all-players-tracking.md](all-players-tracking.md) for the recommended `ctx.phase` tracking pattern.\n',
+  "references/hands-vs-decks.md": '# Hands vs Decks\n\nThe framework distinguishes between **Hands** and **Decks**. Confusing them causes silent bugs.\n\n## Definitions\n\n| Concept  | Manifest key                  | Type ID  | Access API                               | Description                                                  |\n| -------- | ----------------------------- | -------- | ---------------------------------------- | ------------------------------------------------------------ |\n| **Hand** | `playerHandDefinitions`       | `HandId` | `state.player.getHand(playerId, handId)` | Cards owned by a specific player. Per-player.                |\n| **Deck** | `components` (type: `"deck"`) | `DeckId` | `state.deck.getCards(deckId)`            | Shared card piles (draw pile, discard, battle zone). Global. |\n\n## Key rule\n\nA player\'s collection of cards is always a **Hand** (`HandId`), even if the real-world game calls it a "deck."\n\nFor example, in the War card game, each player\'s face-down pile is called a "deck" in real life, but in the framework it\'s defined as a **Hand** with id `"player-deck"` under `playerHandDefinitions`.\n\n## Manifest Example (War card game)\n\n```json\n{\n  "components": [\n    { "type": "deck", "id": "main-deck", "name": "Main Deck" },\n    { "type": "deck", "id": "battle-zone", "name": "Battle Zone" },\n    { "type": "deck", "id": "war-pile", "name": "War Pile" }\n  ],\n  "playerHandDefinitions": [\n    {\n      "id": "player-deck",\n      "displayName": "Your Deck",\n      "visibility": "ownerOnly"\n    },\n    { "id": "won-pile", "displayName": "Won Cards", "visibility": "ownerOnly" }\n  ]\n}\n```\n\n- `"player-deck"` \u2192 **HandId** (per-player) \u2192 `state.player.getHand(playerId, "player-deck")`\n- `"battle-zone"` \u2192 **DeckId** (shared) \u2192 `state.deck.getCards("battle-zone")`\n- `"war-pile"` \u2192 **DeckId** (shared) \u2192 `state.deck.getCards("war-pile")`\n\n## Moving Cards\n\n```typescript\n// Hand \u2192 Deck (player plays card to shared area)\napis.cardApi.moveCardsFromHandToDeck(playerId, handId, cardIds, deckId);\n\n// Deck \u2192 Hand (deal from shared pile to player)\napis.deckApi.moveCardsFromDeckToPlayer(deckId, playerId, handId, count);\n\n// Hand \u2192 Hand (pass cards between players)\napis.cardApi.moveCardsFromHandToHand(\n  fromPlayer,\n  fromHand,\n  toPlayer,\n  toHand,\n  cardIds,\n);\n\n// Deck \u2192 Deck (move all cards between shared piles)\napis.deckApi.moveCardsFromDeckToDeck(fromDeckId, toDeckId);\n\n// Any card \u2192 Hand (move specific cards to a player)\napis.cardApi.moveCardsToPlayer(cardIds, toPlayerId, handId);\n```\n\n## Hand Passing: Anti-Pattern vs Safe Pattern\n\n`moveCardsFromHandToHand` appends to destination. That makes in-place cyclic passing unsafe.\n\n### Anti-pattern (in-place cyclic pass)\n\n```typescript\nfor (let i = 0; i < order.length; i++) {\n  const fromPlayer = order[i];\n  const toPlayer = order[(i + 1) % order.length];\n  const cardIds = state.player.getHand(fromPlayer, "hand");\n  apis.cardApi.moveCardsFromHandToHand(\n    fromPlayer,\n    "hand",\n    toPlayer,\n    "hand",\n    cardIds,\n  );\n}\n```\n',
+  "references/manifest-authoring.md": '# Manifest Authoring Guide\n\n`manifest.json` is the source of truth for your game\'s structure \u2014 components, actions, state machine, and variables. After editing, run `dreamboard update` to regenerate scaffolded files (`app/phases/`, `shared/manifest.d.ts`, etc.).\n\n## Top-Level Structure\n\n```json\n{\n  "version": "1.0.0",\n  "playerConfig": { ... },\n  "deckDefinitions": [ ... ],\n  "playerHandDefinitions": [ ... ],\n  "components": [ ... ],\n  "resources": [ ... ],\n  "boardDefinitions": [ ... ],\n  "availableActions": [ ... ],\n  "stateMachine": { ... },\n  "variableSchema": { ... }\n}\n```\n\n| Field                   | Required | Description                                        |\n| ----------------------- | -------- | -------------------------------------------------- |\n| `version`               | \u2705       | Manifest version - increment manually when updated |\n| `playerConfig`          | \u2705       | Min/max/optimal player counts                      |\n| `deckDefinitions`       | \u2705       | Card deck blueprints (preset or manual)            |\n| `playerHandDefinitions` | \u2705       | Per-player card containers                         |\n| `components`            | \u2705       | Shared game components (decks, dice)               |\n| `resources`             | \u274C       | Typed resource economy (gold, wood)                |\n| `boardDefinitions`      | \u274C       | Spatial boards (hex, network, square, track)       |\n| `availableActions`      | \u2705       | Player submission buttons                          |\n| `stateMachine`          | \u2705       | Game phases and transitions                        |\n| `variableSchema`        | \u2705       | Minimal state for game logic                       |\n\n---\n\n## Authoring Sequence\n\nWork through sections in this order. Skip any step that doesn\'t apply to your game.\n\n### 1. `playerConfig`\n\n```json\n{\n  "playerConfig": {\n    "minPlayers": 2,\n    "maxPlayers": 4,\n    "optimalPlayers": 4\n  }\n}\n```\n\n| Field            | Type    | Range | Description                          |\n| ---------------- | ------- | ----- | ------------------------------------ |\n| `minPlayers`     | integer | 1\u201310  | Minimum players required             |\n| `maxPlayers`     | integer | 1\u201310  | Maximum players supported            |\n| `optimalPlayers` | integer | 1\u201310  | Best player count for the experience |\n\n### 2. `deckDefinitions`\n\nDeck definitions are blueprints for card types. There are two kinds:\n\n#### Preset decks\n\nUse `"standard_52_deck"` for standard playing cards. **Do NOT define 52 cards manually.**\n\n```json\n{\n  "deckDefinitions": [\n    {\n      "type": "preset",\n      "id": "standard_52_deck",\n      "name": "Standard 52-Card Deck"\n    }\n  ]\n}\n```\n\n#### Manual (custom) decks\n\nDefine your own cards with a `cardSchema` and a `cards` list.\n\n```json\n{\n  "type": "manual",\n  "id": "resource-deck",\n  "name": "Resource Cards",\n  "cardSchema": {\n    "properties": {\n      "value": { "type": "integer", "description": "Point value of the card" },\n      "category": { "type": "string", "description": "Resource category" }\n    }\n  },\n  "cards": [\n    {\n      "type": "lumber",\n      "name": "Lumber",\n      "count": 4,\n      "properties": { "value": "1", "category": "wood" }\n    },\n    {\n      "type": "brick",\n      "name": "Brick",\n      "count": 3,\n      "properties": { "value": "2", "category": "stone" }\n    }\n  ]\n}\n```\n\n**Card fields:**\n\n| Field        | Required | Description                                                                              |\n| ------------ | -------- | ---------------------------------------------------------------------------------------- |\n| `type`       | \u2705       | Card type ID. Runtime IDs are generated as `{type}-1`, `{type}-2`, etc. when `count > 1` |\n| `name`       | \u2705       | Display name                                                                             |\n| `count`      | \u2705       | Number of copies (\u2265 1)                                                                   |\n| `properties` | \u2705       | Values matching `cardSchema` (all values are strings)                                    |\n| `imageUrl`   | \u274C       | Card image URL                                                                           |\n| `text`       | \u274C       | Text content on the card                                                                 |\n| `cardType`   | \u274C       | Optional category within the deck                                                        |\n\n**Property schema types:** `string`, `integer`, `number`, `boolean`, `array`, `object`, `enum`, `deckId`, `cardId`, `playerId`\n\n### 3. `playerHandDefinitions`\n\nPer-player card containers. Each player gets their own instance automatically.\n\n```json\n{\n  "playerHandDefinitions": [\n    {\n      "id": "main-hand",\n      "displayName": "Hand",\n      "visibility": "ownerOnly",\n      "maxCards": 7,\n      "deckDefinitionIds": ["standard_52_deck"]\n    },\n    {\n      "id": "score-pile",\n      "displayName": "Scored Cards",\n      "visibility": "public"\n    }\n  ]\n}\n```\n\n| Field               | Required | Default       | Description                                                 |\n| ------------------- | -------- | ------------- | ----------------------------------------------------------- |\n| `id`                | \u2705       | \u2014             | Unique hand ID (becomes `HandId` type)                      |\n| `displayName`       | \u2705       | \u2014             | UI label                                                    |\n| `visibility`        | \u274C       | `"ownerOnly"` | `"ownerOnly"`, `"public"`, or `"hidden"`                    |\n| `maxCards`          | \u274C       | \u2014             | Maximum cards allowed                                       |\n| `minCards`          | \u274C       | \u2014             | Minimum cards required                                      |\n| `deckDefinitionIds` | \u274C       | \u2014             | Restrict to cards from these deck definitions (empty = any) |\n| `description`       | \u274C       | \u2014             | Purpose description                                         |\n\n> **DECK vs HAND:** `DeckComponent` (in `components`) is **shared** \u2014 one instance per game (draw piles, discard piles, trick zones). `PlayerHandDefinition` is **per-player** \u2014 private hands, tableaus, collected cards.\n\n### 4. `components` \u2014 Shared Decks\n\nDeck components are shared game zones that reference a deck definition.\n\n```json\n{\n  "components": [\n    {\n      "type": "deck",\n      "id": "draw-pile",\n      "name": "Draw Pile",\n      "deckDefinitionId": "standard_52_deck",\n      "layout": "stack"\n    },\n    {\n      "type": "deck",\n      "id": "discard-pile",\n      "name": "Discard Pile",\n      "deckDefinitionId": "standard_52_deck",\n      "layout": "spread"\n    }\n  ]\n}\n```\n\n| Field              | Required | Default   | Description                             |\n| ------------------ | -------- | --------- | --------------------------------------- |\n| `type`             | \u2705       | \u2014         | `"deck"`                                |\n| `id`               | \u2705       | \u2014         | Unique component ID                     |\n| `name`             | \u2705       | \u2014         | Display name                            |\n| `deckDefinitionId` | \u2705       | \u2014         | Which deck definition this sources from |\n| `layout`           | \u274C       | `"stack"` | `"stack"`, `"spread"`, or `"fan"`       |\n\n### 5. `components` \u2014 Dice\n\nAdd dice as components with `type: "die"`.\n\n```json\n{\n  "type": "die",\n  "id": "d6-die",\n  "name": "Six-Sided Die",\n  "sides": 6\n}\n```\n\n| Field   | Required | Description                                   |\n| ------- | -------- | --------------------------------------------- |\n| `type`  | \u2705       | `"die"`                                       |\n| `id`    | \u2705       | Unique die ID (e.g., `"d6-die"`, `"d20-die"`) |\n| `name`  | \u2705       | Display name                                  |\n| `sides` | \u2705       | Number of sides (\u2265 2)                         |\n\n### 6. `resources` (Optional)\n\nTyped resource economy for games with currencies or materials. Resources have a dedicated API (`canAfford`, `deduct`, `add`, `transfer`).\n\n```json\n{\n  "resources": [\n    { "id": "gold", "name": "Gold" },\n    { "id": "wood", "name": "Wood" },\n    { "id": "victoryPoints", "name": "Victory Points" }\n  ]\n}\n```\n\n| Field  | Required | Description                                                        |\n| ------ | -------- | ------------------------------------------------------------------ |\n| `id`   | \u2705       | Unique resource ID (alphanumeric + underscore, starts with letter) |\n| `name` | \u2705       | Display name                                                       |\n\n> **Don\'t duplicate resources in `playerVariableSchema`.** Use the resource system instead.\n\n### 7. `boardDefinitions` (Optional)\n\nFor games with spatial structure. Each board type has its own shape:\n\n| Board Type | Use Case                              | Key Concepts                                                                                      |\n| ---------- | ------------------------------------- | ------------------------------------------------------------------------------------------------- |\n| `hex`      | Hexagonal grids (Catan)               | Tiles (pre-defined with IDs/types), Edges `[TileId, TileId]`, Vertices `[TileId, TileId, TileId]` |\n| `network`  | Graph maps (Ticket to Ride, Pandemic) | Nodes (locations using TileId), Edges `[TileId, TileId]`                                          |\n| `square`   | Grid boards (Chess, Checkers)         | Cells derived from row/col (e.g., `"a1"` to `"h8"`), Pieces placed on cells                       |\n| `track`    | Path boards (Monopoly, VP track)      | Sequential spaces with IDs, pieces on spaces                                                      |\n\n### 8. `availableActions`\n\nActions are **submissions** (buttons), **NOT selections**. Card/tile selection happens via UI clicks \u2014 the action definition declares the parameters that carry the selected items in the POST request.\n\n```json\n{\n  "availableActions": [\n    {\n      "actionType": "playCard",\n      "displayName": "Play Card",\n      "description": "Play the selected card from your hand",\n      "parameters": [\n        {\n          "name": "cardId",\n          "type": "cardId",\n          "required": true,\n          "array": false,\n          "deckDefinitionId": "standard_52_deck"\n        }\n      ],\n      "errorCodes": ["NOT_YOUR_TURN", "INVALID_CARD", "MUST_FOLLOW_SUIT"]\n    },\n    {\n      "actionType": "pass",\n      "displayName": "Pass",\n      "parameters": [],\n      "errorCodes": ["CANNOT_PASS"]\n    },\n    {\n      "actionType": "discardCards",\n      "displayName": "Discard",\n      "parameters": [\n        {\n          "name": "cardIds",\n          "type": "cardId",\n          "required": true,\n          "array": true,\n          "minLength": 1,\n          "maxLength": 3,\n          "deckDefinitionId": "standard_52_deck"\n        }\n      ],\n      "errorCodes": ["WRONG_COUNT", "CARD_NOT_IN_HAND"]\n    }\n  ]\n}\n```\n\n**ActionDefinition fields:**\n\n| Field         | Required | Description                                                               |\n| ------------- | -------- | ------------------------------------------------------------------------- |\n| `actionType`  | \u2705       | Unique ID in camelCase (e.g., `"playCard"`, `"rollDice"`)                 |\n| `displayName` | \u2705       | Button label                                                              |\n| `description` | \u274C       | Help text                                                                 |\n| `parameters`  | \u2705       | List of parameters (can be empty for parameterless actions like `"pass"`) |\n| `errorCodes`  | \u274C       | Possible validation error codes                                           |\n\n**ActionParameterDefinition fields:**\n\n| Field              | Required | Default | Description                                           |\n| ------------------ | -------- | ------- | ----------------------------------------------------- |\n| `name`             | \u2705       | \u2014       | Parameter name                                        |\n| `type`             | \u2705       | \u2014       | See parameter types below                             |\n| `required`         | \u274C       | `true`  | Whether required                                      |\n| `array`            | \u274C       | `false` | Set `true` when multiple values can be sent           |\n| `minLength`        | \u274C       | \u2014       | Min items (only when `array: true`)                   |\n| `maxLength`        | \u274C       | \u2014       | Max items (only when `array: true`)                   |\n| `deckDefinitionId` | \u274C       | \u2014       | Links `"cardId"` params to a specific deck definition |\n| `description`      | \u274C       | \u2014       | Help text                                             |\n\n**Parameter types:**\n\n| Type           | Description                                                 |\n| -------------- | ----------------------------------------------------------- |\n| `"cardId"`     | Runtime card instance ID (e.g., `"lumber-1"`, `"lumber-2"`) |\n| `"cardType"`   | Manifest-level card type identifier (e.g., `"lumber"`)      |\n| `"deckId"`     | Deck component ID                                           |\n| `"playerId"`   | Player ID                                                   |\n| `"string"`     | Free-form string                                            |\n| `"number"`     | Numeric value                                               |\n| `"boolean"`    | Boolean value                                               |\n| `"tileId"`     | Hex tile or network node ID                                 |\n| `"edgeId"`     | Edge between tiles/nodes                                    |\n| `"vertexId"`   | Vertex between tiles                                        |\n| `"spaceId"`    | Track board space ID                                        |\n| `"pieceId"`    | Board piece ID                                              |\n| `"zoneId"`     | Zone ID                                                     |\n| `"tokenId"`    | Token ID                                                    |\n| `"resourceId"` | Resource ID                                                 |\n\n**Key rules:**\n\n- **NO `"selectCard"` actions.** UI clicks are not actions.\n- If an action involves cards, **always include a `cardId` parameter** with the correct `deckDefinitionId`. Use `array: true` when multiple cards can be sent.\n- Never use placeholder string params or empty parameter lists when the action consumes card data.\n- Use `"cardId"` for specific card instances, `"cardType"` for card categories.\n- Use camelCase for `actionType` names.\n- Always use the specific type (e.g. deckId, cardId, playerId, etc) to narrow the parameter type instead of string where appropriate.\n\n### 9. `stateMachine`\n\nDefine game phases and transitions.\n\n```json\n{\n  "stateMachine": {\n    "initialState": "dealCards",\n    "states": [\n      {\n        "name": "dealCards",\n        "type": "AUTO",\n        "description": "Shuffle the deck and deal 7 cards to each player.",\n        "transitions": [{ "targetState": "playCard" }],\n        "autoAdvance": true\n      },\n      {\n        "name": "playCard",\n        "type": "SINGLE_PLAYER",\n        "description": "Active player must play a valid card or draw from the pile.",\n        "availableActions": ["playCard", "drawCard"],\n        "transitions": [\n          { "targetState": "playCard", "description": "Next player\'s turn" },\n          {\n            "targetState": "gameOver",\n            "description": "Player has no cards left"\n          }\n        ],\n        "autoAdvance": true\n      },\n      {\n        "name": "gameOver",\n        "type": "AUTO",\n        "description": "Calculate final scores and determine the winner.",\n        "transitions": []\n      }\n    ]\n  }\n}\n```\n\n**State types:**\n\n| Type            | Description                                                 | Example                                     |\n| --------------- | ----------------------------------------------------------- | ------------------------------------------- |\n| `SINGLE_PLAYER` | Engine waits for **one** player to act, then auto-advances  | Chess turns, Poker betting                  |\n| `ALL_PLAYERS`   | Engine waits for **all** players to submit before advancing | Rock-Paper-Scissors, 7 Wonders card passing |\n| `AUTO`          | No player interaction \u2014 executes immediately                | Dealing, scoring, state checks              |\n\n**StateDefinition fields:**\n\n| Field              | Required | Default | Description                                                                     |\n| ------------------ | -------- | ------- | ------------------------------------------------------------------------------- |\n| `name`             | \u2705       | \u2014       | Unique state name in camelCase (use verbNoun format: `dealCards`, `playTurn`)   |\n| `type`             | \u2705       | \u2014       | `AUTO`, `SINGLE_PLAYER`, or `ALL_PLAYERS`                                       |\n| `description`      | \u2705       | \u2014       | Full logic description \u2014 what happens, what players can do                      |\n| `availableActions` | \u274C       | \u2014       | Action types available in this state (only for `SINGLE_PLAYER` / `ALL_PLAYERS`) |\n| `transitions`      | \u2705       | \u2014       | List of possible next states                                                    |\n| `autoAdvance`      | \u274C       | `true`  | Whether to auto-advance when complete                                           |\n\n**StateTransition fields:**\n\n| Field         | Required | Description                     |\n| ------------- | -------- | ------------------------------- |\n| `targetState` | \u2705       | Name of the next state          |\n| `description` | \u274C       | When/why this transition occurs |\n\n### 10. `variableSchema`\n\nMinimal state for game logic. Split into global (shared) and per-player variables.\n\n```json\n{\n  "variableSchema": {\n    "globalVariableSchema": {\n      "properties": {\n        "currentRound": {\n          "type": "integer",\n          "description": "Current round number"\n        },\n        "trumpSuit": { "type": "string", "description": "Current trump suit" }\n      }\n    },\n    "playerVariableSchema": {\n      "properties": {\n        "score": { "type": "integer", "description": "Player\'s current score" },\n        "hasPassed": {\n          "type": "boolean",\n          "description": "Whether player has passed this round"\n        }\n      }\n    }\n  }\n}\n```\n\n**Rules for variables:**\n\n- **MINIMIZE state.** Only include what\'s needed for rules and logic.\n- \u2705 **Include:** scores, flags (`hasPassed`), logic blockers (`lastPlayedCards`), trump suit, round counters\n- \u274C **Exclude:** derivable data (hand sizes, deck sizes, current player \u2014 the engine tracks these)\n- \u274C **Don\'t duplicate resources** \u2014 use the `resources` section instead of player variables for economies\n- Use `globalVariableSchema` for shared/global state (turn counter, current round)\n- Use `playerVariableSchema` for per-player state (scores, flags)\n\n**Property types:** `string`, `integer`, `number`, `boolean`, `array` (with `items`), `object` (with `properties`), `enum` (with `enums` list), `deckId`, `cardId`, `playerId`\n\n---\n\n## ID Naming Conventions\n\n- Use **human-readable, kebab-case IDs** for components and hands: `"draw-pile"`, `"main-hand"`, `"d6-die"`\n- Use **camelCase** for state names and action types: `"dealCards"`, `"playCard"`, `"rollDice"`\n- Use **camelCase** for variable names: `"currentRound"`, `"hasPassed"`, `"trumpSuit"`\n- Resource IDs: alphanumeric + underscore, starting with a letter: `"gold"`, `"victoryPoints"`\n\n---\n\n## Minimal Example\n\nA simple draw-and-play card game for 2\u20134 players:\n\n```json\n{\n  "version": "1.0.0",\n  "playerConfig": {\n    "minPlayers": 2,\n    "maxPlayers": 4,\n    "optimalPlayers": 3\n  },\n  "deckDefinitions": [\n    {\n      "type": "preset",\n      "id": "standard_52_deck",\n      "name": "Standard 52-Card Deck"\n    }\n  ],\n  "playerHandDefinitions": [\n    {\n      "id": "main-hand",\n      "displayName": "Hand",\n      "visibility": "ownerOnly",\n      "maxCards": 7,\n      "deckDefinitionIds": ["standard_52_deck"]\n    }\n  ],\n  "components": [\n    {\n      "type": "deck",\n      "id": "draw-pile",\n      "name": "Draw Pile",\n      "deckDefinitionId": "standard_52_deck",\n      "layout": "stack"\n    },\n    {\n      "type": "deck",\n      "id": "discard-pile",\n      "name": "Discard Pile",\n      "deckDefinitionId": "standard_52_deck",\n      "layout": "spread"\n    }\n  ],\n  "availableActions": [\n    {\n      "actionType": "playCard",\n      "displayName": "Play Card",\n      "description": "Play a card from your hand to the discard pile",\n      "parameters": [\n        {\n          "name": "cardId",\n          "type": "cardId",\n          "required": true,\n          "deckDefinitionId": "standard_52_deck"\n        }\n      ],\n      "errorCodes": ["NOT_YOUR_TURN", "INVALID_PLAY"]\n    },\n    {\n      "actionType": "drawCard",\n      "displayName": "Draw Card",\n      "description": "Draw a card from the draw pile",\n      "parameters": [],\n      "errorCodes": ["HAND_FULL", "DECK_EMPTY"]\n    }\n  ],\n  "stateMachine": {\n    "initialState": "dealCards",\n    "states": [\n      {\n        "name": "dealCards",\n        "type": "AUTO",\n        "description": "Shuffle the deck and deal 5 cards to each player. Place remaining cards face-down as the draw pile. Flip the top card to start the discard pile.",\n        "transitions": [{ "targetState": "playTurn" }]\n      },\n      {\n        "name": "playTurn",\n        "type": "SINGLE_PLAYER",\n        "description": "Active player must play a matching card from their hand or draw from the draw pile. A card matches if it shares the same suit or rank as the top discard.",\n        "availableActions": ["playCard", "drawCard"],\n        "transitions": [\n          { "targetState": "playTurn", "description": "Next player\'s turn" },\n          {\n            "targetState": "endRound",\n            "description": "Player empties their hand"\n          }\n        ]\n      },\n      {\n        "name": "endRound",\n        "type": "AUTO",\n        "description": "The player who emptied their hand wins. Calculate scores based on cards remaining in other players\' hands.",\n        "transitions": []\n      }\n    ]\n  },\n  "variableSchema": {\n    "globalVariableSchema": {\n      "properties": {}\n    },\n    "playerVariableSchema": {\n      "properties": {\n        "score": {\n          "type": "integer",\n          "description": "Accumulated score across rounds"\n        }\n      }\n    }\n  }\n}\n```\n\n---\n\n## After Editing\n\nRun `dreamboard update` to push the manifest and regenerate scaffolded files:\n\n```bash\ndreamboard update\n```\n\nThis regenerates:\n\n- `app/phases/` \u2014 One handler file per state in the state machine\n- `shared/manifest.d.ts` \u2014 TypeScript type definitions derived from the manifest\n- Action handler stubs and variable type definitions\n',
+  "references/phase-handlers.md": '# Phase Handlers\n\nPhase handlers are the core abstraction for implementing game logic. Each state in the manifest\'s `stateMachine` maps to a phase handler file in `app/phases/`.\n\n## Phase Types\n\n| Type            | File Import                 | When to use                                                  |\n| --------------- | --------------------------- | ------------------------------------------------------------ |\n| `AUTO`          | `createAutoPhase`           | No player input needed (deal, resolve, score)                |\n| `SINGLE_PLAYER` | `createSinglePlayerPhase`   | One player acts at a time (play a card, roll dice)           |\n| `ALL_PLAYERS`   | `createMultiplePlayerPhase` | All players act simultaneously (reveal, pass cards, discard) |\n\n## Phase Lifecycle\n\n**AUTO**: `execute(ctx)` \u2192 returns next state name\n\n**SINGLE_PLAYER / ALL_PLAYERS**:\n\n1. `onEnter(ctx)` \u2014 initialize phase state, set active players\n2. `validateAction(ctx, playerId, actionType, parameters)` \u2014 validate before execution\n3. `onPlayerAction(ctx, playerId, actionType, parameters)` \u2014 process the action (mutate state)\n4. `onAfterAction(ctx, playerId, actionType)` \u2014 per-action side effects (e.g., advance turn)\n5. `checkCompletion(ctx)` \u2014 return `null` if not done, or the next state name if done\n6. `onComplete(ctx)` \u2014 cleanup after transition decision\n\n## PhaseContext (`ctx`)\n\n```typescript\ninterface PhaseContext {\n  readonly state: StateApi; // Read game state\n  readonly apis: GameApis; // Mutate game state\n  readonly logger: Logger; // Log messages\n}\n```\n\n## AUTO Phase Example\n\n```typescript\nimport type { AutoPhaseDefinition } from "../sdk/phaseHandlers";\nimport { createAutoPhase } from "../sdk/phaseHandlers";\n\nconst phaseDefinition = {\n  execute(ctx) {\n    const { state, apis, logger } = ctx;\n    apis.deckApi.shuffle("main-deck");\n    for (const playerId of state.player.getOrder()) {\n      apis.deckApi.moveCardsFromDeckToPlayer(\n        "main-deck",\n        playerId,\n        "main-hand",\n        5,\n      );\n    }\n    return "playPhase";\n  },\n} satisfies AutoPhaseDefinition<"dealCards">;\n\nexport const phase = createAutoPhase(phaseDefinition);\n```\n\n## SINGLE_PLAYER Phase Example\n\n```typescript\nimport type { SinglePlayerPhaseDefinition } from "../sdk/phaseHandlers";\nimport { createSinglePlayerPhase } from "../sdk/phaseHandlers";\nimport { validationSuccess, validationError } from "../sdk/validation.js";\n\nconst phaseDefinition = {\n  onEnter(ctx) {\n    const { state, apis } = ctx;\n    const firstPlayer = state.player.getOrder()[0];\n    apis.gameApi.setNextPlayer(firstPlayer);\n  },\n\n  validateAction(ctx, playerId, actionType, parameters) {\n    return validationSuccess();\n  },\n\n  onPlayerAction(ctx, playerId, actionType, parameters) {\n    const { apis } = ctx;\n    // Process action...\n  },\n\n  onAfterAction(ctx, playerId, actionType) {\n    const { apis } = ctx;\n    apis.gameApi.advanceTurn(); // Move to next player\n  },\n\n  checkCompletion(ctx) {\n    // Return null to keep playing, or next state name to transition\n    return null;\n  },\n\n  getUIArgs(ctx, playerId) {\n    return {};\n  },\n} satisfies SinglePlayerPhaseDefinition<"playPhase", "playCard">;\n\nexport const phase = createSinglePlayerPhase(phaseDefinition);\n```\n\n## ALL_PLAYERS Phase Example\n\nSee [all-players-tracking.md](all-players-tracking.md) for the recommended tracking pattern.\n\n## Terminal Phase (Game End)\n\nFor states with no transitions (game end), use `TerminalPhaseDefinition`:\n\n```typescript\nimport type { TerminalPhaseDefinition } from "../sdk/phaseHandlers";\nimport { createTerminalPhase } from "../sdk/phaseHandlers";\n\nconst phaseDefinition = {\n  execute(ctx) {\n    const { state, apis } = ctx;\n    // Optionally declare winner\n    apis.gameApi.declareWinner("player-1", "Most points");\n    apis.gameApi.endGame();\n    return "endGame";\n  },\n} satisfies TerminalPhaseDefinition<"endGame">;\n\nexport const phase = createTerminalPhase(phaseDefinition);\n```\n\n## Type Safety\n\nPhase definitions use `satisfies` for type checking:\n\n- `AutoPhaseDefinition<\'stateName\'>` \u2014 state name from manifest\n- `SinglePlayerPhaseDefinition<\'stateName\', \'actionName\'>` \u2014 with action type union\n- `MultiplePlayerPhaseDefinition<\'stateName\', \'actionName\'>` \u2014 for ALL_PLAYERS\n- Union multiple actions: `\'playCard\' | \'drawCard\'`\n',
+  "references/rule-authoring.md": '# Rule Authoring Guide\n\n`rule.md` is the source of truth for game intent. A strong rule document leads to better manifest generation, better phase scaffolding, and fewer logic bugs.\n\n## Recommended Document Structure\n\nUse this section order in `rule.md`.\n\n1. **Overview**\n\n   - Game premise and objective.\n   - Player count (min/max/optimal).\n   - Match length target (for example 15-25 minutes).\n\n2. **Components**\n\n   - Cards, decks, hands, tokens, dice, boards, resources.\n   - Public vs hidden information.\n   - Limits (deck sizes, hand limits, token caps).\n\n3. **Setup**\n\n   - Initial board/deck/resource setup.\n   - Starting player and initial turn order.\n   - Initial cards/resources per player.\n\n4. **Gameplay**\n\n   - Turn or phase loop in order.\n   - Available actions per phase.\n   - Validation constraints for actions.\n   - Transition conditions between phases.\n\n5. **Scoring and Progression**\n\n   - How points/resources/progress are gained or lost.\n   - When scoring occurs (per action, end of round, end of game).\n   - Tie-breakers.\n\n6. **Winning Conditions**\n\n   - Exact end-game triggers.\n   - Winner resolution rules, including ties.\n\n7. **Special Rules and Edge Cases**\n   - Simultaneous actions.\n   - Empty deck behavior.\n   - Invalid/no-op action handling.\n   - What happens when a player cannot act.\n\n## Authoring Rules That Map Cleanly to Engine Concepts\n\nWrite rules in a way that maps directly to Dreamboard systems:\n\n- **Phase model**\n\n  - State whether a phase is automatic, single-player, or all-players.\n  - State completion criteria for each phase.\n\n- **Action model**\n\n  - Define each action by name, intent, and required inputs.\n  - Include action constraints ("must", "cannot", min/max quantities).\n\n- **State model**\n\n  - Separate persistent state from derived state.\n  - Prefer explicit counters/flags over vague conditions.\n\n- **Visibility model**\n\n  - Specify what each player can see at all times.\n  - Explicitly call out hidden hands, private choices, and reveal timing.\n\n- **Determinism**\n  - Resolve "if multiple options apply" with priority order.\n  - Define random events precisely (shuffle, draw count, tie randomization).\n\n## Writing Style Requirements\n\n- Use explicit modal language:\n  - Use "must" for mandatory behavior.\n  - Use "may" only for optional player choices.\n- Define terms once and reuse them exactly.\n- Avoid UI instructions ("click", "drag") in rule logic.\n\n## High-Signal Template\n\nUse this template when creating or rewriting `rule.md`:\n\n```markdown\n# <Game Name>\n\n## Overview\n\n- Players: <min-max> (optimal: <n>)\n- Objective: <how to win>\n- Duration: <target minutes>\n\n## Components\n\n- Decks:\n- Player hands:\n- Shared zones:\n- Resources/tokens/dice:\n- Public vs hidden info:\n\n## Setup\n\n1. ...\n2. ...\n3. ...\n\n## Gameplay\n\n### Phase 1: <name> (<AUTO|SINGLE_PLAYER|ALL_PLAYERS>)\n\n- Entry:\n- Allowed actions:\n- Validation:\n- Completion -> Next phase:\n\n### Phase 2: <name> ...\n\n## Scoring and Progression\n\n- ...\n\n## Winning Conditions\n\n- End trigger:\n- Winner determination:\n- Tie-breaker:\n```\n\n## Iteration Workflow\n\n1. Edit `rule.md` first.\n2. Align `manifest.json` to the updated rules.\n3. Run `dreamboard update` to regenerate scaffolding.\n4. Implement/refine `app/phases/*.ts`.\n5. Validate flow with `dreamboard run`.\n',
+  "references/scenario-format.md": '# Scenario Format\n\nScenarios are JSON files used with `dreamboard run --scenario <file>` to automate gameplay actions.\n\nUse this file for the JSON runtime-scenario contract.\n\n- For TypeScript regression tests with `dreamboard test generate` / `dreamboard test run`, see [test-harness.md](test-harness.md).\n- For what adversarial cases to write with these JSON scenarios, see [adversarial-testing.md](adversarial-testing.md).\n\n`dreamboard run` is now a single command flow:\n\n1. Without `--scenario`, it observes SSE until a stop condition (default `YOUR_TURN`).\n2. With `--scenario`, it executes scenario steps (default `--max-steps 1`).\n3. Scenario driver defaults to `api` (no Playwright required).\n4. Playwright is used only for `--scenario-driver ui` or `--screenshot`.\n\n## Default Structure (API Driver)\n\n```json\n{\n  "steps": [\n    {\n      "playerId": "player-1",\n      "actionType": "playCard",\n      "parameters": { "cardId": "hearts-7" },\n      "turns": 1\n    },\n    {\n      "playerId": "player-1",\n      "actionType": "endTurn",\n      "parameters": {},\n      "turns": 1\n    }\n  ]\n}\n```\n\n## API Step Fields (Default)\n\n| Field        | Type                      | Description                                                       |\n| ------------ | ------------------------- | ----------------------------------------------------------------- |\n| `playerId`   | `string`                  | Player ID this step applies to (required)                         |\n| `actionType` | `string`                  | Action type submitted to runtime API (required)                   |\n| `parameters` | `Record<string, unknown>` | Action parameters object (optional, default `{}`)                 |\n| `turns`      | `number`                  | Number of turns to wait after this action (optional, default `1`) |\n\n## UI Step Fields (`--scenario-driver ui`)\n\n| Field      | Type       | Description                                                                 |\n| ---------- | ---------- | --------------------------------------------------------------------------- |\n| `playerId` | `string`   | Player ID this step applies to (required)                                   |\n| `buttons`  | `string[]` | Mouse/keyboard buttons to simulate (`"left_mouse_button"`, `"right"`, etc.) |\n| `turns`    | `number`   | Number of turns to apply this step                                          |\n| `mouse_x`  | `number`   | X coordinate of the simulated click (optional)                              |\n| `mouse_y`  | `number`   | Y coordinate of the simulated click (optional)                              |\n\n## Conventions\n\n1. `playerId` is required on every step.\n2. Run one acting step per invocation for deterministic agent loops:\n   - `dreamboard run` (observe turn context)\n   - `dreamboard run --scenario ... --max-steps 1` (act once)\n3. All steps executed in one invocation must target the same `playerId`.\n4. The step `playerId` must be eligible for the latest `YOUR_TURN` context.\n\n## Observe Artifacts\n\nWhen running without `--scenario`, the CLI writes:\n\n1. `.dreamboard/run/session.json`\n2. `.dreamboard/run/events.ndjson`\n3. `.dreamboard/run/latest-your-turn.json`\n4. `.dreamboard/run/last-run-summary.json`\n\nBy default, `events.ndjson` stores only `YOUR_TURN` messages.\n\n## Usage\n\n```bash\n# Observe until actionable state (default: until YOUR_TURN)\ndreamboard run\n\n# Observe stream behavior\ndreamboard run --until GAME_ENDED\ndreamboard run --observe-events all\ndreamboard run --timeout-ms 15000\ndreamboard run --screenshot\n\n# Execute API scenario steps (default driver, no Playwright required)\ndreamboard run --scenario path/to/scenario.json\ndreamboard run --scenario path/to/scenario.json --max-steps 1\n\n# Execute UI scenario steps (Playwright driver)\ndreamboard run --scenario path/to/scenario.json --scenario-driver ui --max-steps 1\ndreamboard run --scenario path/to/scenario.json --scenario-driver ui --max-steps 1 --screenshot\n\n# Start a fresh session instead of resuming\ndreamboard run --new-session --players 4\n```\n',
+  "references/test-harness.md": '# Test Harness\n\nTypeScript scenario tests run against the Dreamboard backend API using deterministic base snapshots.\n\nUse this file for the TypeScript regression harness:\n\n- `dreamboard test generate`\n- `dreamboard test run`\n\nThis is not the same system as `dreamboard run --scenario <file>.json`.\n\n- For JSON runtime scenarios, see [scenario-format.md](scenario-format.md).\n- For rejection-focused runtime coverage, see [adversarial-testing.md](adversarial-testing.md).\n\n## Workspace Layout\n\nThe harness expects this structure in the game project:\n\n- `test/base-scenarios.json`\n- `test/scenarios/*.scenario.ts`\n- `test/generated/*` (generated by `dreamboard test generate`)\n\nCurrent canonical example workspace (`examples/things-in-rings`) includes bases like `initial-turn` and `after-first-placement`, plus scenarios under `test/scenarios/`.\n\n## Commands\n\nGenerate deterministic bases:\n\n```bash\ndreamboard test generate\n```\n\nRun all scenarios:\n\n```bash\ndreamboard test run\n```\n\nRun one scenario file:\n\n```bash\ndreamboard test run --scenario test/scenarios/reject-card-not-in-hand.scenario.ts\n```\n\nSource-checkout builds may expose internal environment overrides for harness work, but those flags are not part of the published CLI contract.\n\nRegenerate whenever any fingerprint input changes: base definition (`seed`, `players`, `steps`), game manifest hash, compiled result ID, or game ID.\n\n## Base Definitions\n\n`test/base-scenarios.json` is required and must explicitly include `initial-turn`.\n\nEach base entry has:\n\n- `seed: number`\n- `players: number`\n- `steps: ApiScenarioStep[]`\n\n`steps` may be empty. Use an empty-step base plus an empty-step scenario to assert opening-state invariants without inventing fake actions.\n\nExample:\n\n```json\n{\n  "initial-turn": {\n    "seed": 1337,\n    "players": 4,\n    "steps": []\n  },\n  "after-first-placement": {\n    "seed": 1337,\n    "players": 4,\n    "steps": [\n      {\n        "playerId": "player-2",\n        "actionType": "placeThing",\n        "parameters": { "cardId": "a-shadow", "ringId": "ring-1" }\n      }\n    ]\n  }\n}\n```\n\nGeneration flow for each used base:\n\n1. Create session with deterministic seed/player count.\n2. Start game.\n3. Wait for first `YOUR_TURN`.\n4. Execute base setup steps.\n5. Save snapshot + fingerprint metadata.\n\nBase setup events are not counted in test assertions. `events` in `then.assert` only reflects actions from `when.steps`, so zero-step scenarios start with an empty event history.\n\n## Generated Artifacts\n\n`dreamboard test generate` writes:\n\n- `test/generated/base-states.generated.ts`\n- `test/generated/base-states.generated.d.ts`\n- `test/generated/scenario-manifest.generated.ts`\n- `test/generated/.generation-meta.json`\n\nThese files are generated and should not be edited manually.\n\n## Scenario Contract\n\nScenarios are loaded from `test/scenarios/**/*.scenario.ts` and validated strictly (unknown fields are rejected).\n\nIn current projects, scenario files typically import from `../testing-types`:\n\n```ts\nimport { AssertContext, defineScenario } from "../testing-types";\n\nexport default defineScenario({\n  meta: {\n    id: "reject-card-not-in-hand",\n    description: "Player tries to place a card they don\'t hold",\n  },\n  given: {\n    base: "initial-turn",\n  },\n  when: {\n    steps: [\n      {\n        playerId: "player-2",\n        actionType: "placeThing",\n        parameters: { cardId: "a-dog", ringId: "ring-1" },\n      },\n    ],\n  },\n  then: {\n    assert: ({ gameState, events, expect }: AssertContext) => {\n      expect(events.count("ACTION_REJECTED")).toBe(1);\n      expect(events.last("ACTION_REJECTED")?.errorCode).toBe(\n        "CARD_NOT_IN_HAND",\n      );\n      expect(gameState.currentState).toBe("placeThing");\n    },\n  },\n});\n```\n\n`given.base` must exist in `test/base-scenarios.json`, or the run fails with an available-base list.\n\nFor invariant coverage, add at least one zero-step scenario:\n\n```ts\nimport {\n  AssertContext,\n  defineScenario,\n  getNormalizedHands,\n} from "../testing-types";\n\nexport default defineScenario({\n  meta: {\n    id: "initial-state",\n    description: "Opening hands are dealt to the correct players",\n  },\n  given: {\n    base: "initial-turn",\n  },\n  when: {\n    steps: [],\n  },\n  then: {\n    assert: ({ gameState, expect }: AssertContext) => {\n      const hands = getNormalizedHands(gameState);\n      expect(hands["player-1"]?.hand).toEqual([\n        "seat-1-flower-1",\n        "seat-1-flower-2",\n        "seat-1-flower-3",\n        "seat-1-skull",\n      ]);\n    },\n  },\n});\n```\n\n## Runtime Assertion Surface\n\n`then.assert` receives `{ gameState, events, expect }`.\n\n- `events.count(type)` returns number of matching events.\n- `events.last(type)` returns the latest matching event.\n- `events.all(type)` returns all matching events.\n- `expect(actual)` supports `toBe`, `toEqual`, `toBeDefined`, `toContain`, and `toBeGreaterThanOrEqual`.\n\nDuring scenario assertions, event history includes only scenario steps (base-step events are cleared before scenario execution).\n\n`gameState.globalVariables` and `gameState.playerVariables` are JSON-parsed for assertions.\n\n`testing-types` also exports:\n\n- `getNormalizedHands(gameState)` to read each player hand with sorted card IDs.\n- `getNormalizedDecks(gameState)` to read deck contents with sorted card IDs.\n\n## Failure And Staleness Signals\n\nCommon failures indicate stale generated bases:\n\n- `Missing test/generated/base-states.generated.ts. Run \'dreamboard test generate\' first.`\n- `Fingerprint mismatch: base setup changed (...). Run \'dreamboard test generate\' to refresh deterministic bases.`\n- `Fingerprint mismatch: compiled result changed (...). Run \'dreamboard test generate\' to refresh deterministic bases.`\n- `Fingerprint mismatch: base setup changed (...); compiled result changed (...). Run \'dreamboard test generate\' to refresh deterministic bases.`\n- Unknown `given.base` values.\n\n## Common edge cases\n\nWhen testing out-of-turn behavior in any turn-based game, include these checks:\n\n- Wrong actor attempts a valid action: choose a base where the active player is known, send a normal action from a different player, and assert a turn-violation error (for example `NOT_YOUR_TURN`).\n- Unauthorized role attempts an action: if your game has role-restricted actions, attempt the action from an actor without permission and assert the appropriate authorization error.\n- Correct actor, wrong phase/state: attempt an action that is valid in one phase/state while the game is in another, and assert a deterministic phase/state rejection.\n- Consecutive out-of-turn attempts: send multiple invalid actions from different non-active players and verify each is rejected independently.\n- No state mutation on rejection: assert no successful action event was emitted, the game phase/state is unchanged, and the active player pointer is unchanged.\n\nRecommended assertion template:\n\n```ts\nexpect(events.count("ACTION_REJECTED")).toBe(1);\nexpect(events.count("ACTION_EXECUTED")).toBe(0);\nexpect(events.last("ACTION_REJECTED")?.errorCode).toBe("NOT_YOUR_TURN");\nexpect(gameState.currentState).toBe(expectedState);\nexpect(gameState.currentPlayerIds[0]).toBe(expectedActivePlayerId);\n```\n',
+  "references/tts-migration-and-extractor.md": "# Migrate From TTS\n\nGiven a workshop ID, full workshop URL, or location of a `.bin` file, use `extract_tts.py` to parse a TTS save into structured JSON and optionally download referenced assets.\n\n## Prereqs\n\n- Python 3\n- `steamcmd` (only needed when passing a Workshop ID instead of a local `.bin` file)\n\nVerify `steamcmd`:\n\n```sh\nsteamcmd +quit\n```\n\n### macOS\n\n```sh\nbrew install --cask steamcmd\n```\n\n### Windows\n\n1. Download `steamcmd.zip` from Valve: `https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip`\n2. Extract to a permanent folder, e.g. `C:\\steamcmd\\`\n3. Add that folder to your `PATH`\n4. Run once so it self-updates:\n\n```cmd\nsteamcmd +quit\n```\n\n## Basic Usage\n\n```sh\npython3 extract_tts.py <workshop_id> [output_dir]\npython3 extract_tts.py <workshop_url> [output_dir]\npython3 extract_tts.py <save.bin> [output_dir]\n```\n\nWorkshop ID is the numeric `id` from the Steam Workshop URL, e.g.\n`https://steamcommunity.com/sharedfiles/filedetails/?id=3385562324` -> `3385562324`.\n\n## Download Referenced Assets\n\nUse `--download` to fetch assets referenced in `asset_urls.json` and write `asset_files.json` with local relative paths.\n\n```sh\npython3 extract_tts.py <workshop_id|workshop_url|save.bin> [output_dir] --download\n```\n\nOptional tuning:\n\n```sh\npython3 extract_tts.py <workshop_id|workshop_url|save.bin> [output_dir] --download --download-workers 8 --download-rps 2.5\n```\n\n- `--download-workers`: max concurrent workers (default `6`, capped internally)\n- `--download-rps`: global request rate limit across workers (default `3.0` req/s)\n\nDownloaded files are stored under `assets/` with inferred subfolders such as `assets/pdf/`, `assets/deck/`, `assets/image/`, and `assets/mesh/`.\n\n## Recommended Flow Into Dreamboard\n\n```sh\npython3 extract_tts.py <workshop_id> [output_dir] --download\ndreamboard new <slug> ...\nmv [output_dir] <slug>/assets\n```\n\n## Output Files\n\n| File                 | Contents                                                                                        |\n| -------------------- | ----------------------------------------------------------------------------------------------- |\n| `metadata.json`      | Save name, date, version, tags, table/sky URLs, play time, player counts                        |\n| `asset_urls.json`    | Asset URLs grouped by TTS object nickname/type, with deck/card/PDF metadata                     |\n| `asset_urls.txt`     | Flat list of every unique URL                                                                   |\n| `asset_files.json`   | Same shape as `asset_urls.json`, but with local relative file paths (when `--download` is used) |\n| `objects.json`       | Per-object summary (GUID, name, custom deck/image/PDF info, contained objects)                  |\n| `scripts/`           | Each unique Lua script and XML UI saved as individual files                                     |\n| `scripts_index.json` | Maps each scripted object (GUID/path) to its script file                                        |\n| `full_save.json`     | Full parsed save tree with large script bodies replaced by placeholders                         |\n| `tab_states.json`    | Player-colour tab contents (if present)                                                         |\n| `snap_points.json`   | Table snap point positions (if present)                                                         |\n\n## How To Use The Extracted Data\n\n- Use `CustomPDF` / `PDFUrl` entries in `asset_urls.json` (or local files in `asset_files.json`) as source material for `rule.md`.\n- Use `TableURL` and `SkyURL` as references for UI tone and color direction.\n- Use `FaceURL` plus card grid metadata (`numWidth`, `numHeight`, `row`, `column`) to reconstruct decks/cards in `manifest.json`.\n- Use card metadata (`nickname`, `count`, `description`, `gmNotes`) to seed content and balancing decisions.\n",
+  "references/ui-best-practices.md": '# UI Best Practices\n\nBest practices for working on `ui/App.tsx` and `ui/components/*` \u2014 the React frontend.\n\n## General principles\n\n1. **Use SDK components** \u2014 import from `./sdk/components/`. Prefer library components over rolling your own. Customize them via render props if needed.\n2. **Mobile-first** \u2014 mobile is the primary target, desktop is an enhancement. Start with mobile-optimized layouts, use large touch targets, and relative units (rem, em).\n3. **No state duplication** \u2014 avoid `React.useState()` for state that needs to sync across players. Use `useGameState`, `useUIArgs`, and action submitters instead.\n4. **Error handling on actions** \u2014 always wrap action submissions in try/catch and show feedback via `useToast`.\n5. **Do not use `any`** \u2014 always work with typed hooks and props.\n6. **Persistent feedback matters** \u2014 include a stable feedback region that survives auto-phase transitions so players can always see the current phase, latest status message, last round result, and game-over summary.\n\n## SDK hooks (from `./sdk/hooks/`)\n\n| Hook                   | Returns                                                           | When to use                                                                                                                                     |\n| ---------------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |\n| `useGameState`         | Full game state (currentPlayerIds, decks, currentState, isMyTurn) | Core game state. All fields are non-nullable \u2014 do not use optional chaining.                                                                    |\n| `useCard(cardId)`      | `CardItem \\| undefined`                                           | Get a single card\'s data                                                                                                                        |\n| `useCards(cardIds)`    | `CardItem[]`                                                      | Get multiple cards                                                                                                                              |\n| `useMyHand(handId)`    | Hand data for current player                                      | Player\'s cards                                                                                                                                  |\n| `useMyResources()`     | Current player\'s resources                                        | Resource display                                                                                                                                |\n| `useMe`                | `{ playerId, name, isHost }`                                      | Current player identity                                                                                                                         |\n| `usePlayerInfo`        | Map of all players                                                | Player list/display                                                                                                                             |\n| `useAction`            | Phase-specific action submitters                                  | Submitting actions. Keyed by phase with "Actions" suffix (e.g., `playCardsActions`). Only current phase returns submitters; others return null. |\n| `useUIArgs`            | Phase-specific UI args                                            | Data from `getUIArgs()`. Keyed by phase name. Only current phase has data.                                                                      |\n| `useGameNotifications` | Event listeners                                                   | `onYourTurn`, `onActionRejected`, `onGameEnded`                                                                                                 |\n| `useLobby`             | Lobby state                                                       | seats, canStart, hostUserId                                                                                                                     |\n| `useDice(dieIds)`      | Dice values and roll function                                     | Dice mechanics                                                                                                                                  |\n\n## SDK components (from `./sdk/components/`)\n\n### Core display\n\n| Component       | Purpose                                                                                      |\n| --------------- | -------------------------------------------------------------------------------------------- |\n| `Card`          | Displays a game card with animations. Supports `renderContent` for custom faces.             |\n| `ConnectedCard` | Auto-fetches card data from context.                                                         |\n| `Hand`          | Container for player\'s hand. Uses render props: `renderCard`, `renderDrawer`, `renderEmpty`. |\n| `PlayArea`      | Central board area for active cards. Supports grid/row layouts.                              |\n| `PlayerInfo`    | Player avatar with status, score, and turn indicators.                                       |\n\n### Action UI\n\n| Component      | Purpose                                                      |\n| -------------- | ------------------------------------------------------------ |\n| `ActionButton` | Button with integrated cost display and affordability check. |\n| `ActionPanel`  | Collapsible container for action groups.                     |\n| `ActionGroup`  | Groups related actions with title and variant styling.       |\n\n### Game state display\n\n| Component         | Purpose                                                             |\n| ----------------- | ------------------------------------------------------------------- |\n| `PhaseIndicator`  | Shows current phase and "Your Turn" indicator.                      |\n| `ResourceCounter` | Displays resource counts with icons and animations.                 |\n| `CostDisplay`     | Shows resource costs with green/red affordability indication.       |\n| `DiceRoller`      | Display component for dice values with render prop.                 |\n| `GameEndDisplay`  | End-of-game overlay with trophy, scoreboard, and return-to-lobby.   |\n| `Drawer`          | Mobile-friendly drawer for overflow content (e.g., too many cards). |\n\n### Board components\n\n| Component      | Use case                                | Hook                              |\n| -------------- | --------------------------------------- | --------------------------------- |\n| `SquareGrid`   | Chess, Checkers, Go, Tic-Tac-Toe        | `useSquareBoard(boardId)`         |\n| `HexGrid`      | Catan, wargames, Hive                   | `useHexBoard(boardId)`            |\n| `TrackBoard`   | Monopoly, racing, Snakes & Ladders      | `useTrackBoard(boardId)`          |\n| `NetworkGraph` | Ticket to Ride, Pandemic, Power Grid    | `useNetworkBoard(boardId)`        |\n| `ZoneMap`      | Risk, Small World, area control         | `useZoneMap(zones, pieces)`       |\n| `SlotSystem`   | Agricola, Viticulture, worker placement | `useSlotSystem(slots, occupants)` |\n\n## Layout guidelines\n\n- Use Tailwind CSS for all styling.\n- Use `clsx` for conditional class composition.\n- Use `framer-motion` for animations (already included via SDK components).\n- Keep spacing tight on mobile, generous on desktop.\n- Limit simultaneous animations for performance.\n- Use `useIsMobile()` hook when you need device-specific behavior.\n\n## Persistent feedback region\n\nReserve a visible area near the top of the layout for game status. This should outlive individual action panels and phase-specific subviews.\n\n- Show the current phase and whether it is the local player\'s turn.\n- Show a human-readable status message for the latest meaningful change.\n- Keep the last round result visible until the next player-facing state can explain it.\n- Show a clear game-over summary when the game ends.\n\nIf your game uses AUTO phases, do not let those transitions wipe the only copy of round-resolution feedback before the UI can render it.\n\n## Common patterns\n\n### Phase-based rendering\n\n```tsx\nconst { currentState, isMyTurn } = useGameState();\nconst uiArgs = useUIArgs();\nconst actions = useAction();\n\n// Render based on current phase\nif (currentState === "playCards") {\n  const phaseArgs = uiArgs.playCards;\n  const phaseActions = actions.playCardsActions;\n  return <PlayCardsView args={phaseArgs} actions={phaseActions} />;\n}\n```\n\n### Action submission with error handling\n\n```tsx\nconst { toast } = useToast();\n\nconst handlePlay = async () => {\n  try {\n    await actions.playCardsActions.playCard({ cardIds: selectedCards });\n  } catch (err) {\n    toast.error(err instanceof Error ? err.message : "Action failed");\n  }\n};\n```\n\n### Game end detection\n\n```tsx\nconst { currentState } = useGameState();\n\nif (currentState === "endGame") {\n  return <GameEndDisplay isGameOver scores={scores} />;\n}\n```\n\n## Public hands in UI\n\nFor public card zones (for example a scored area), prefer the built-in hook instead of custom `getUIArgs()` plumbing.\n\n```ts\nimport { useMyHand, usePublicHands } from "@dreamboard/ui-sdk";\n\nconst myHand = useMyHand("hand");\nconst scoredByPlayer = usePublicHands("scored-area");\nconst player2Scored = scoredByPlayer["player-2"] ?? [];\n```\n\nNotes:\n\n- `useMyHand(handId)` returns cards for the currently controlling player only.\n- `usePublicHands(handId)` returns all players\' cards for that hand, keyed by `playerId`.\n- `usePublicHands()` is only populated for hands marked `"visibility": "public"`.\n\n## Genre-specific guidance\n\nFor detailed UI patterns and recommended components per game genre, see:\n\n- [ui-genre-trick-taking.md](ui-genre-trick-taking.md) \u2014 Hearts, Spades, Bridge, Big Two\n- [ui-genre-worker-placement.md](ui-genre-worker-placement.md) \u2014 Agricola, Viticulture, Lords of Waterdeep\n- [ui-genre-resource-management.md](ui-genre-resource-management.md) \u2014 Catan, Splendor, engine builders\n',
+  "references/ui-genre-resource-management.md": '# UI Guide: Resource Management Games\n\nPatterns for Catan, Splendor, engine builders, trading games, and similar resource-centric games.\n\n## Game characteristics\n\n- Players **collect, spend, and trade resources** to build structures, buy cards, or score points.\n- May involve a shared board (hex grid, network, market row) plus personal tableaux.\n- Key UI signals: resource pools, affordability, available purchases, trade offers, build options.\n\n## Recommended SDK components\n\n### Primary\n\n| Component                     | Usage                                                                      |\n| ----------------------------- | -------------------------------------------------------------------------- |\n| `ResourceCounter`             | Display each player\'s resource pool with icons and animated count changes. |\n| `CostDisplay`                 | Show build/purchase costs with green/red affordability feedback.           |\n| `ActionButton`                | "Build", "Buy", "Trade" buttons with integrated cost display.              |\n| `ActionPanel` / `ActionGroup` | Organize actions by type (Build, Trade, End Turn).                         |\n| `Card` / `Hand`               | Display purchasable cards or player tableau cards.                         |\n\n### Board components (pick based on game)\n\n| Component      | Use case                                  | Hook                       |\n| -------------- | ----------------------------------------- | -------------------------- |\n| `HexGrid`      | Catan-style resource hex boards           | `useHexBoard(boardId)`     |\n| `NetworkGraph` | Trade route networks                      | `useNetworkBoard(boardId)` |\n| `SquareGrid`   | Grid-based markets or tableaux            | `useSquareBoard(boardId)`  |\n| `PlayArea`     | Market row / available cards for purchase | \u2014                          |\n\n### Supporting\n\n| Component        | Usage                                                    |\n| ---------------- | -------------------------------------------------------- |\n| `PlayerInfo`     | Player name, score, and victory point tracker.           |\n| `PhaseIndicator` | Current phase (roll, trade, build, etc.).                |\n| `DiceRoller`     | For dice-based resource generation (e.g., Catan).        |\n| `GameEndDisplay` | Final scores with score breakdown.                       |\n| `Drawer`         | Mobile drawer for trade interface or detailed card view. |\n\n### Hooks\n\n| Hook                       | Usage                                                 |\n| -------------------------- | ----------------------------------------------------- |\n| `useMyResources()`         | Current player\'s resource counts.                     |\n| `useHexBoard(boardId)`     | Hex board state for Catan-style games.                |\n| `useNetworkBoard(boardId)` | Network/route state.                                  |\n| `useSquareBoard(boardId)`  | Grid board state.                                     |\n| `useDice(dieIds)`          | Dice rolling mechanics.                               |\n| `useGameState`             | Turn order, current phase, active players.            |\n| `useAction`                | Submit build, trade, end-turn actions.                |\n| `useUIArgs`                | Phase-specific data (available builds, trade offers). |\n| `usePlayerInfo`            | All player info for scoreboards.                      |\n\n## Key patterns\n\n### Resource display with affordability\n\n```tsx\nconst resources = useMyResources();\nconst resourceDefs: ResourceDefinition[] = [\n  { type: "brick", label: "Brick", icon: Blocks, color: "text-red-600" },\n  { type: "lumber", label: "Lumber", icon: TreePine, color: "text-green-700" },\n  { type: "ore", label: "Ore", icon: Mountain, color: "text-slate-500" },\n  { type: "grain", label: "Grain", icon: Wheat, color: "text-yellow-500" },\n  { type: "wool", label: "Wool", icon: Cloud, color: "text-green-400" },\n];\n\n<ResourceCounter\n  resources={resourceDefs.map((d) => ({\n    ...d,\n    iconColor: d.color,\n    bgColor: "bg-slate-800",\n  }))}\n  counts={resources}\n  layout="row"\n/>;\n```\n\n### Build actions with costs\n\n```tsx\nconst { buildPhase } = useUIArgs();\nconst resources = useMyResources();\n\n<ActionPanel title="Build" state="buildPhase">\n  <ActionGroup title="Structures">\n    <ActionButton\n      label="Build Road"\n      cost={{ brick: 1, lumber: 1 }}\n      currentResources={resources}\n      resourceDefs={resourceDefs}\n      available={buildPhase?.canBuildRoad}\n      onClick={() => actions.buildActions.build({ type: "road" })}\n    />\n    <ActionButton\n      label="Build Settlement"\n      cost={{ brick: 1, lumber: 1, grain: 1, wool: 1 }}\n      currentResources={resources}\n      resourceDefs={resourceDefs}\n      available={buildPhase?.canBuildSettlement}\n      onClick={() => actions.buildActions.build({ type: "settlement" })}\n    />\n  </ActionGroup>\n</ActionPanel>;\n```\n\n### Hex board for Catan-style games\n\n```tsx\nconst { tiles, edges, vertices } = useHexBoard("catan-board");\n\n<HexGrid\n  tiles={tiles}\n  edges={edges}\n  vertices={vertices}\n  hexSize={50}\n  renderTile={(tile) => (\n    <DefaultHexTile\n      size={50}\n      fill={terrainColors[tile.typeId]}\n      label={tile.data?.diceNumber}\n    />\n  )}\n  renderEdge={(edge, pos) => (\n    <DefaultHexEdge position={pos} color={playerColors[edge.owner]} />\n  )}\n  renderVertex={(vertex, pos) => (\n    <DefaultHexVertex position={pos} color={playerColors[vertex.owner]} />\n  )}\n  interactiveVertices={placementMode === "settlement"}\n  interactiveEdges={placementMode === "road"}\n  onInteractiveVertexClick={(v) => handlePlacement("settlement", v.id)}\n  onInteractiveEdgeClick={(e) => handlePlacement("road", e.id)}\n/>;\n```\n\n### Market row (purchasable cards)\n\n```tsx\n<PlayArea\n  cards={marketCards}\n  layout="row"\n  interactive\n  onCardClick={(cardId) => handlePurchase(cardId)}\n  renderCard={(card) => (\n    <div className="relative">\n      <DefaultCardContent card={card} />\n      <CostDisplay\n        cost={card.properties.cost}\n        currentResources={resources}\n        resourceDefs={resourceDefs}\n        layout="inline"\n      />\n    </div>\n  )}\n/>\n```\n\n## UIArgs recommendations\n\n```typescript\n// shared/ui-args.ts\nexport interface BuildPhaseUIArgs {\n  canBuildRoad: boolean;\n  canBuildSettlement: boolean;\n  canBuildCity: boolean;\n  canBuyCard: boolean;\n  availableBuildLocations?: string[]; // Board positions where building is allowed\n}\n\nexport interface TradePhaseUIArgs {\n  canTrade: boolean;\n  tradeOffers?: {\n    from: string;\n    offering: Record<string, number>;\n    requesting: Record<string, number>;\n  }[];\n  bankTradeRatios?: Record<string, number>; // e.g., { brick: 4, lumber: 3 } for ports\n}\n\nexport interface DicePhaseUIArgs {\n  diceValues?: number[];\n  resourcesGained?: Record<string, number>;\n}\n```\n',
+  "references/ui-genre-trick-taking.md": '# UI Guide: Trick-Taking Games\n\nPatterns for Hearts, Spades, Bridge, Big Two, and similar card-based trick-taking games.\n\n## Game characteristics\n\n- Players hold a **hand of cards** and play them to a shared **trick area**.\n- One trick is resolved at a time; the winner collects cards.\n- Turn order matters \u2014 typically clockwise from the trick leader.\n- Key UI signals: whose turn it is, which cards are legal to play, current trick, scores.\n\n## Recommended SDK components\n\n### Primary\n\n| Component    | Usage                                                                                               |\n| ------------ | --------------------------------------------------------------------------------------------------- |\n| `Hand`       | Display the current player\'s hand. Use `renderCard` to highlight playable cards.                    |\n| `Card`       | Render individual cards in the hand and trick area. Use `renderContent` for custom suit/rank faces. |\n| `PlayArea`   | Display the current trick \u2014 cards played by each player. Use `layout="row"`.                        |\n| `PlayerInfo` | Show each player\'s name, score, and turn indicator around the table.                                |\n\n### Supporting\n\n| Component        | Usage                                                       |\n| ---------------- | ----------------------------------------------------------- |\n| `PhaseIndicator` | Show current phase (dealing, passing, playing, scoring).    |\n| `GameEndDisplay` | Final scoreboard at game end.                               |\n| `useToast`       | Feedback for invalid plays (e.g., "Must follow suit").      |\n| `Drawer`         | Overflow drawer when the hand has too many cards on mobile. |\n\n### Hooks\n\n| Hook                 | Usage                                                                      |\n| -------------------- | -------------------------------------------------------------------------- |\n| `useMyHand(handId)`  | Get the current player\'s cards.                                            |\n| `useCard / useCards` | Resolve card data for display.                                             |\n| `useGameState`       | Get `currentPlayerIds`, `isMyTurn`, `currentState`.                        |\n| `useAction`          | Submit play-card action.                                                   |\n| `useUIArgs`          | Get phase-specific data (e.g., legal card IDs, trick cards, trick winner). |\n| `usePlayerInfo`      | Map player IDs to names for trick display.                                 |\n\n## Key patterns\n\n### Card selection for play\n\n```tsx\nconst [selectedCards, setSelectedCards] = useState<string[]>([]);\nconst { playCards } = useUIArgs();\nconst legalCardIds = new Set(playCards?.legalCardIds ?? []);\n\n<Hand\n  cards={myCards}\n  selectedIds={selectedCards}\n  renderCard={({ card, isSelected, ...pos }) => (\n    <Card\n      card={card}\n      selected={isSelected}\n      disabled={!legalCardIds.has(card.id)}\n      onCardClick={(id) => toggleSelection(id)}\n      style={{\n        position: "absolute",\n        left: pos.x,\n        transform: `translateY(${pos.y}px)`,\n        zIndex: pos.zIndex,\n      }}\n    />\n  )}\n  renderDrawer={({ cards }) => <DrawerContent cards={cards} />}\n  renderEmpty={() => <p>No cards</p>}\n/>;\n```\n\n### Trick display with player labels\n\n```tsx\nconst playerInfo = usePlayerInfo();\nconst { playCards } = useUIArgs();\nconst trickCards = playCards?.trickCards ?? []; // { cardId, playerId }[]\n\n<PlayArea\n  cards={resolvedCards}\n  layout="row"\n  renderCard={(card) => (\n    <div className="flex flex-col items-center gap-1">\n      <span className="text-xs text-slate-400">\n        {playerInfo[card.properties?.playedBy]?.name}\n      </span>\n      <SuitRankCard card={card} />\n    </div>\n  )}\n/>;\n```\n\n## UIArgs recommendations\n\n```typescript\n// shared/ui-args.ts\nexport interface PlayCardsUIArgs {\n  legalCardIds: string[]; // Cards the player can legally play\n  trickCards: { cardId: string; playerId: string }[]; // Cards in the current trick\n  trickLeader: string | null; // Who led the trick\n  trumpSuit?: string; // Trump suit if applicable\n}\n\nexport interface ScoringUIArgs {\n  roundScores: Record<string, number>;\n  totalScores: Record<string, number>;\n}\n```\n',
+  "references/ui-genre-worker-placement.md": '# UI Guide: Worker Placement Games\n\nPatterns for Agricola, Viticulture, Lords of Waterdeep, Caverna, and similar euro-style worker placement games.\n\n## Game characteristics\n\n- Players place **worker tokens** on shared **action slots** to gain resources or take actions.\n- Slots may be exclusive (one player per round) or shared.\n- Phases typically include: placement, resolution/harvest, and cleanup.\n- Key UI signals: available slots, slot costs/rewards, number of workers remaining, resource counts.\n\n## Recommended SDK components\n\n### Primary\n\n| Component             | Usage                                                                                                 |\n| --------------------- | ----------------------------------------------------------------------------------------------------- |\n| `SlotSystem`          | Core board \u2014 renders all action slots with occupants. Use `layout="grouped"` to organize by category. |\n| `DefaultSlotItem`     | Pre-built slot renderer showing name, description, capacity, cost/reward labels.                      |\n| `DefaultSlotOccupant` | Pre-built worker token display with player color.                                                     |\n| `ResourceCounter`     | Display each player\'s resource pool (wood, stone, food, etc.).                                        |\n| `ActionButton`        | "Place Worker" button with integrated cost display and affordability check.                           |\n\n### Supporting\n\n| Component                     | Usage                                                        |\n| ----------------------------- | ------------------------------------------------------------ |\n| `ActionPanel` / `ActionGroup` | Group available actions (e.g., "Place Worker", "End Turn").  |\n| `CostDisplay`                 | Show resource costs on slot details.                         |\n| `PlayerInfo`                  | Show each player\'s name, workers remaining, and turn status. |\n| `PhaseIndicator`              | Distinguish placement phase from harvest/scoring phases.     |\n| `GameEndDisplay`              | Final scoring with detailed breakdown.                       |\n| `Drawer`                      | Mobile drawer for detailed slot inspection.                  |\n\n### Hooks\n\n| Hook                              | Usage                                                                                          |\n| --------------------------------- | ---------------------------------------------------------------------------------------------- |\n| `useSlotSystem(slots, occupants)` | Utility for slot lookups: `getSlot`, `isFull`, `getRemainingCapacity`, `getOccupantsByPlayer`. |\n| `useMyResources()`                | Current player\'s resource pool.                                                                |\n| `useGameState`                    | Get `isMyTurn`, `currentState`, `currentPlayerIds`.                                            |\n| `useAction`                       | Submit place-worker or end-turn actions.                                                       |\n| `useUIArgs`                       | Get phase-specific data (available slots, worker count, etc.).                                 |\n| `usePlayerInfo`                   | Map player IDs to names and colors.                                                            |\n\n## Key patterns\n\n### Slot board with placement\n\n```tsx\nconst { placementPhase } = useUIArgs();\nconst slots = placementPhase?.slots ?? [];\nconst occupants = placementPhase?.occupants ?? [];\nconst availableSlotIds = new Set(placementPhase?.availableSlotIds ?? []);\nconst slotApi = useSlotSystem(slots, occupants);\n\n<SlotSystem\n  slots={slots}\n  occupants={occupants}\n  layout="grouped"\n  renderSlot={(slot, slotOccupants) => (\n    <DefaultSlotItem\n      name={slot.name}\n      description={slot.description}\n      capacity={slot.capacity}\n      occupantCount={slotOccupants.length}\n      isExclusive={slot.exclusive}\n      isAvailable={availableSlotIds.has(slot.id)}\n      costLabel={formatCost(slot.cost)}\n      rewardLabel={formatReward(slot.reward)}\n      onClick={() => handlePlaceWorker(slot.id)}\n      renderOccupants={() => (\n        <div className="flex gap-1">\n          {slotOccupants.map((o) => (\n            <DefaultSlotOccupant\n              key={o.pieceId}\n              color={playerColors[o.playerId]}\n              label={playerInfo[o.playerId]?.name}\n            />\n          ))}\n        </div>\n      )}\n    />\n  )}\n/>;\n```\n\n### Resource display\n\n```tsx\nconst resources = useMyResources();\n\n<ResourceCounter\n  resources={[\n    {\n      type: "wood",\n      label: "Wood",\n      icon: TreePine,\n      iconColor: "text-amber-700",\n    },\n    {\n      type: "stone",\n      label: "Stone",\n      icon: Mountain,\n      iconColor: "text-slate-400",\n    },\n    { type: "food", label: "Food", icon: Apple, iconColor: "text-red-400" },\n    { type: "gold", label: "Gold", icon: Coins, iconColor: "text-yellow-400" },\n  ]}\n  counts={resources}\n  layout="row"\n/>;\n```\n\n### Action buttons with costs\n\n```tsx\n<ActionButton\n  label="Build Farm"\n  cost={{ wood: 2, stone: 1 }}\n  currentResources={resources}\n  resourceDefs={resourceDefinitions}\n  icon={Home}\n  onClick={() => actions.buildActions.build({ buildingType: "farm" })}\n/>\n```\n\n## UIArgs recommendations\n\n```typescript\n// shared/ui-args.ts\nexport interface PlacementPhaseUIArgs {\n  slots: SlotDefinition[];\n  occupants: SlotOccupant[];\n  availableSlotIds: string[]; // Slots the current player can legally place on\n  workersRemaining: number;\n}\n\nexport interface HarvestPhaseUIArgs {\n  feedingRequired: number; // Food needed\n  currentFood: number;\n}\n```\n',
+  "references/ui-style-guide.md": '# UI Style Guide\n\nThis style guide details the design philosophy, visual tokens, and core components for the Dreamboard.games UI SDK. The framework uses a **Hand-Drawn** aesthetic that emphasizes human creativity over corporate polish.\n\n## Design Philosophy\n\nThe Hand-Drawn design style celebrates authentic imperfection and human touch in a digital world. It rejects clinical precision in favor of organic, playful irregularity that evokes sketches on paper, sticky notes on a wall, and napkin diagrams from a brainstorming session.\n\n### Core Principles\n\n- **No Straight Lines**: Every border, shape, and container uses irregular border-radius values to create wobbly, hand-drawn edges that reject geometric perfection.\n- **Authentic Texture**: The design layer paper grain, dot patterns, and subtle background textures to simulate physical media (notebook paper, post-its, sketch pads).\n- **Playful Rotation**: Elements are deliberately tilted using small rotation transforms (`-rotate-1`, `rotate-2`) to break rigid grid alignment and create casual energy.\n- **Hard Offset Shadows**: Reject soft blur shadows entirely. Use solid, offset box-shadows (like `4px 4px 0px`) to create a cut-paper, layered collage aesthetic.\n- **Handwritten Typography**: Use exclusively handwritten or marker-style fonts (like Kalam for headings and Patrick Hand for body text) that feel human and approachable.\n- **Limited Color Palette**: Stick to pencil blacks (`#2d2d2d`), paper whites (`#fdfbf7`), correction marker red (`#ff4d4d`), post-it yellow (`#fff9c4`), and ballpoint blue (`#2d5da1`).\n- **Intentional Messiness**: Embrace overlap, asymmetry, and visual "mistakes" that make the design feel spontaneous.\n\n## CSS Tokens & Utilities\n\nThe platform provides several global CSS utilities designed for this aesthetic:\n\n- **Borders**: `.wobbly-border`, `.wobbly-border-md`, `.wobbly-border-lg` apply the irregular `border-radius` shapes. Used with `border-2`, `border-[3px]`, or `border-[4px]`.\n- **Shadows**: `.hard-shadow`, `.hard-shadow-md`, `.hard-shadow-lg` apply the solid offset shadows. Use `.hard-shadow-sm` for active states (buttons pressing flat).\n\n## Implementing in Components\n\nWhen writing or modifying UI components in `ui/` or `ui-sdk/`:\n\n### Containers & Cards\n\n- Add `wobbly-border-md` or `wobbly-border-lg`.\n- Use `border-[3px] border-border` to give it a thick pencil-like stroke.\n- Apply `bg-[#fdfbf7]` (warm paper) or `bg-white`.\n- Add a solid shadow with `hard-shadow` or `hard-shadow-lg`.\n- Slightly rotate the element with `rotate-1` or `-rotate-1`.\n\n### Buttons\n\n- Use `wobbly-border`.\n- Normal state: `border-[3px] border-border bg-[#fdfbf7] text-foreground hard-shadow`.\n- Hover state: `hover:bg-primary hover:text-white hover:hard-shadow-sm hover:-translate-y-1`.\n- Active state: `active:shadow-none active:translate-y-1 active:translate-x-1`.\n- Secondary variants can use `bg-[#e5e0d8]` or `bg-[#fff9c4]`.\n\n### Typography\n\n- Add `font-sans` for standard handwritten text or `font-display` for bold marker headings.\n- Make things bold! `font-bold` works well with handwritten fonts to make them legible.\n\n### Decoration\n\n- For emphasis, wrap text in a post-it styling: `bg-[#fff9c4] px-2 py-1 border-2 border-border wobbly-border rotate-2 inline-block`.\n- Add "tape" to tops of containers: `<div className="absolute top-2 left-1/2 -translate-x-1/2 w-24 h-6 bg-[#e5e0d8] border border-border opacity-80 backdrop-blur-sm -rotate-2 z-10" />`.\n',
+  "scripts/events-extract.mjs": '#!/usr/bin/env node\n\nimport { access, readFile } from "node:fs/promises";\n\nconst DEFAULT_EVENTS_PATH = ".dreamboard/run/events.ndjson";\n\nfunction printHelp() {\n  console.log(`Extract fields from dreamboard run artifacts.\n\nUsage:\n  node .agents/skills/dreamboard/scripts/events-extract.mjs [options]\n\nOptions:\n  --file, -f <path>       NDJSON file path (default: ${DEFAULT_EVENTS_PATH})\n  --type <eventType>      Filter by event type (repeatable)\n  --field <path>          Dot path to extract (e.g. message.reason)\n  --player <playerId>     Filter by player ID across common message fields\n  --limit <number>        Limit output records\n  --no-index              Omit line index in output\n  --help, -h              Show this help\n\nExamples:\n  node .agents/skills/dreamboard/scripts/events-extract.mjs --type YOUR_TURN\n  node .agents/skills/dreamboard/scripts/events-extract.mjs --type ACTION_REJECTED --field message.reason\n  node .agents/skills/dreamboard/scripts/events-extract.mjs --player player-2 --field message.availableActions\n`);\n}\n\nfunction parseCliArgs(argv) {\n  const options = {\n    filePath: DEFAULT_EVENTS_PATH,\n    types: new Set(),\n    includeIndex: true,\n  };\n\n  for (let index = 0; index < argv.length; index += 1) {\n    const token = argv[index];\n    const nextToken = argv[index + 1];\n\n    if (token === "--help" || token === "-h") {\n      printHelp();\n      process.exit(0);\n    }\n    if (token === "--no-index") {\n      options.includeIndex = false;\n      continue;\n    }\n    if (token === "--file" || token === "-f") {\n      if (!nextToken) {\n        throw new Error("--file requires a value");\n      }\n      options.filePath = nextToken;\n      index += 1;\n      continue;\n    }\n    if (token === "--type") {\n      if (!nextToken) {\n        throw new Error("--type requires a value");\n      }\n      options.types.add(nextToken);\n      index += 1;\n      continue;\n    }\n    if (token === "--field") {\n      if (!nextToken) {\n        throw new Error("--field requires a value");\n      }\n      options.fieldPath = nextToken;\n      index += 1;\n      continue;\n    }\n    if (token === "--player") {\n      if (!nextToken) {\n        throw new Error("--player requires a value");\n      }\n      options.playerId = nextToken;\n      index += 1;\n      continue;\n    }\n    if (token === "--limit") {\n      if (!nextToken) {\n        throw new Error("--limit requires a value");\n      }\n      const parsed = Number.parseInt(nextToken, 10);\n      if (!Number.isFinite(parsed) || parsed <= 0) {\n        throw new Error("--limit must be a positive integer");\n      }\n      options.limit = parsed;\n      index += 1;\n      continue;\n    }\n\n    throw new Error(`Unknown argument: ${token}`);\n  }\n\n  return options;\n}\n\nfunction getByPath(value, path) {\n  const segments = path.split(".").filter(Boolean);\n  let current = value;\n\n  for (const segment of segments) {\n    if (current === null || current === undefined) {\n      return undefined;\n    }\n    if (typeof current !== "object") {\n      return undefined;\n    }\n    current = current[segment];\n  }\n\n  return current;\n}\n\nfunction extractPlayerCandidates(record) {\n  const message = record.message ?? {};\n  const players = new Set();\n\n  const singleCandidates = [\n    message.playerId,\n    message.targetPlayer,\n    message.toUser,\n  ];\n  for (const candidate of singleCandidates) {\n    if (typeof candidate === "string") {\n      players.add(candidate);\n    }\n  }\n\n  const listCandidates = [\n    message.activePlayers,\n    message.previousPlayers,\n    message.currentPlayers,\n    message.controllablePlayerIds,\n    message.eligiblePlayerIds,\n  ];\n  for (const candidate of listCandidates) {\n    if (!Array.isArray(candidate)) {\n      continue;\n    }\n    for (const item of candidate) {\n      if (typeof item === "string") {\n        players.add(item);\n      }\n    }\n  }\n\n  return [...players];\n}\n\nfunction toOutputRecord(record, lineIndex, options) {\n  const output = {};\n\n  if (options.includeIndex) {\n    output.index = lineIndex;\n  }\n  output.observedAt = record.observedAt ?? null;\n  output.sessionId = record.sessionId ?? null;\n  output.eventId = record.eventId ?? null;\n  output.type = record.type ?? null;\n\n  if (options.fieldPath) {\n    output.field = options.fieldPath;\n    output.value = getByPath(record, options.fieldPath);\n  } else {\n    output.message = record.message ?? null;\n  }\n\n  return output;\n}\n\nasync function main() {\n  const options = parseCliArgs(process.argv.slice(2));\n  await access(options.filePath);\n\n  const text = await readFile(options.filePath, "utf8");\n  const lines = text\n    .split(/\\r?\\n/u)\n    .map((line) => line.trim())\n    .filter((line) => line.length > 0);\n\n  let emitted = 0;\n  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {\n    const line = lines[lineIndex];\n    let record;\n    try {\n      record = JSON.parse(line);\n    } catch {\n      continue;\n    }\n\n    if (options.types.size > 0 && !options.types.has(record.type ?? "")) {\n      continue;\n    }\n\n    if (options.playerId) {\n      const players = extractPlayerCandidates(record);\n      if (!players.includes(options.playerId)) {\n        continue;\n      }\n    }\n\n    const output = toOutputRecord(record, lineIndex + 1, options);\n    console.log(JSON.stringify(output));\n    emitted += 1;\n\n    if (options.limit !== undefined && emitted >= options.limit) {\n      break;\n    }\n  }\n}\n\nmain().catch((error) => {\n  const message = error instanceof Error ? error.message : String(error);\n  console.error(`events-extract failed: ${message}`);\n  process.exit(1);\n});\n',
+  "scripts/extract_tts.py": `#!/usr/bin/env python3
+"""
+TTS Binary Save Extractor
+=========================
+Parses Tabletop Simulator's BSON-like binary save format (.bin files) and
+extracts:
+  \u2022 Save metadata (name, date, tags, table/sky URLs, \u2026)
+  \u2022 All asset URLs grouped by TTS object nickname / type
+  \u2022 Every Lua script and XML UI string to individual files
+  \u2022 Per-object summaries (GUID, name, nickname, type, custom asset info, \u2026)
+  \u2022 Full parsed JSON (with script bodies replaced by placeholders)
+  \u2022 Optional download mode that saves assets + emits asset_files.json
+
+Usage:
+    # Extract directly from a .bin file:
+    python3 extract_tts.py <save.bin> [output_dir]
+
+    # Download from Steam Workshop then extract:
+    python3 extract_tts.py <workshop_id> [output_dir]
+
+    # Download referenced assets too:
+    python3 extract_tts.py <save.bin> [output_dir] --download
+"""
+
+import struct
+import argparse
+import json
+import re
+import subprocess
+import sys
+import hashlib
+import mimetypes
+import time
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from collections import defaultdict
+from urllib.parse import urlparse
+from urllib.request import Request, urlopen
+from urllib.error import HTTPError, URLError
+
+# \u2500\u2500\u2500 Type codes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+TYPE_DOUBLE = 0x01   # 8-byte IEEE 754 little-endian double
+TYPE_STRING = 0x02   # 4-byte LE int32 length  +  string bytes  (null-terminated)
+TYPE_OBJECT = 0x03   # 4-byte LE int32 length  +  nested key/value records
+TYPE_ARRAY  = 0x04   # 4-byte LE int32 length  +  integer-keyed nested records
+TYPE_BOOL   = 0x08   # 1 byte  (0x00 = false, anything else = true)
+TYPE_INT32  = 0x10   # 4-byte LE signed int32
+
+HEADER_SIZE = 4      # magic / version bytes at the very start of the file
+
+# \u2500\u2500\u2500 Low-level parser \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+def read_cstring(data: bytes, pos: int):
+    """Return (string, next_pos) for a null-terminated UTF-8 key."""
+    end = data.index(b'\\x00', pos)
+    return data[pos:end].decode('utf-8', errors='replace'), end + 1
+
+
+def parse_records(data: bytes, pos: int, end: int) -> dict:
+    """
+    Recursively parse all key/value records stored in data[pos:end].
+    Returns a plain Python dict.  Unknown type bytes abort the current frame.
+    """
+    result = {}
+    while pos < end:
+        if pos >= len(data):
+            break
+
+        type_byte = data[pos]
+        pos += 1
+
+        # 0x00 = end-of-sequence sentinel; no key/value follows
+        if type_byte == 0x00:
+            break
+
+        key, pos = read_cstring(data, pos)
+
+        if type_byte == TYPE_DOUBLE:
+            value = struct.unpack_from('<d', data, pos)[0]
+            pos += 8
+
+        elif type_byte == TYPE_STRING:
+            length = struct.unpack_from('<i', data, pos)[0]
+            pos += 4
+            raw = data[pos: pos + length]
+            # Strip the trailing null terminator(s) the format always adds
+            value = raw.rstrip(b'\\x00').decode('utf-8', errors='replace')
+            pos += length
+
+        elif type_byte == TYPE_OBJECT:
+            length = struct.unpack_from('<i', data, pos)[0]
+            pos += 4
+            # Length field is self-inclusive: actual content = length - 4 bytes
+            content_size = length - 4
+            value = parse_records(data, pos, pos + content_size)
+            pos += content_size
+
+        elif type_byte == TYPE_ARRAY:
+            length = struct.unpack_from('<i', data, pos)[0]
+            pos += 4
+            content_size = length - 4
+            sub = parse_records(data, pos, pos + content_size)
+            pos += content_size
+            # Convert {"0": \u2026, "1": \u2026} to a plain list
+            arr, i = [], 0
+            while str(i) in sub:
+                arr.append(sub[str(i)])
+                i += 1
+            value = arr
+
+        elif type_byte == TYPE_BOOL:
+            value = bool(data[pos])
+            pos += 1
+
+        elif type_byte == TYPE_INT32:
+            value = struct.unpack_from('<i', data, pos)[0]
+            pos += 4
+
+        else:
+            print(f"  [WARN] Unknown type 0x{type_byte:02X} at byte offset "
+                  f"{pos - 1} \u2014 stopping current frame.",
+                  file=sys.stderr)
+            break
+
+        result[key] = value
+
+    return result
+
+
+# \u2500\u2500\u2500 URL extraction \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+# Fields that are known to carry asset URLs in TTS saves
+URL_FIELD_NAMES = {
+    'TableURL', 'SkyURL',
+    'PDFUrl',
+    'FaceURL', 'BackURL',
+    'ImageURL', 'ImageSecondaryURL',
+    'DiffuseURL', 'NormalURL',
+    'ColliderURL', 'MeshURL',
+    'AssetbundleURL', 'AssetbundleSecondaryURL',
+}
+
+def extract_urls(obj, urls=None):
+    """Walk the parsed save tree and collect every URL by its field name."""
+    if urls is None:
+        urls = defaultdict(set)
+
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            if k in URL_FIELD_NAMES and isinstance(v, str) and v.strip():
+                urls[k].add(v.strip())
+            else:
+                extract_urls(v, urls)
+    elif isinstance(obj, list):
+        for item in obj:
+            extract_urls(item, urls)
+
+    return urls
+
+def extract_urls_for_object(obj, urls=None):
+    """
+    Collect URL fields for a single object without traversing child objects.
+    This keeps nickname-grouped output scoped to each object itself.
+    """
+    if urls is None:
+        urls = defaultdict(set)
+
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            if k in {'ContainedObjects', 'States'}:
+                continue
+            if k in URL_FIELD_NAMES and isinstance(v, str) and v.strip():
+                urls[k].add(v.strip())
+            else:
+                extract_urls_for_object(v, urls)
+    elif isinstance(obj, list):
+        for item in obj:
+            extract_urls_for_object(item, urls)
+
+    return urls
+
+def _simplify_url_fields(urls_by_field):
+    """Convert sets to stable JSON-friendly values (string or list)."""
+    simplified = {}
+    for field in sorted(urls_by_field.keys()):
+        values = sorted(urls_by_field[field])
+        if len(values) == 1:
+            simplified[field] = values[0]
+        else:
+            simplified[field] = values
+    return simplified
+
+def _deck_key_sort_value(deck_key: str):
+    try:
+        return (0, int(deck_key))
+    except (TypeError, ValueError):
+        return (1, str(deck_key))
+
+def _simplify_back_url_map(back_urls_by_id: dict):
+    """Return one BackURL string when all deck IDs share the same URL."""
+    if not back_urls_by_id:
+        return None
+
+    ordered = {
+        deck_id: back_urls_by_id[deck_id]
+        for deck_id in sorted(back_urls_by_id.keys(), key=_deck_key_sort_value)
+    }
+    unique_urls = sorted(set(ordered.values()))
+    if len(unique_urls) == 1:
+        return unique_urls[0]
+    return ordered
+
+def _extract_custom_pdf_info(obj: dict):
+    """Extract CustomPDF metadata from a single object when present."""
+    if not isinstance(obj, dict):
+        return None
+
+    custom_pdf = obj.get('CustomPDF')
+    if not isinstance(custom_pdf, dict):
+        return None
+
+    pdf_url = custom_pdf.get('PDFUrl')
+    if not isinstance(pdf_url, str) or not pdf_url.strip():
+        return None
+
+    page_count = None
+    for key in ('PDFPageCount', 'NumPages', 'PageCount', 'Pages'):
+        raw = custom_pdf.get(key)
+        if isinstance(raw, int) and raw >= 0:
+            page_count = raw
+            break
+
+    current_page = custom_pdf.get('PDFPage')
+    if not isinstance(current_page, int):
+        current_page = None
+
+    page_offset = custom_pdf.get('PDFPageOffset')
+    if not isinstance(page_offset, int):
+        page_offset = None
+
+    return {
+        'url': pdf_url.strip(),
+        'pageCount': page_count,
+        'currentPage': current_page,
+        'pageOffset': page_offset,
+    }
+
+def _collect_card_metadata(objects, by_card_id=None):
+    """Collect explicit per-card metadata from card objects in the tree."""
+    if by_card_id is None:
+        by_card_id = defaultdict(list)
+
+    if not isinstance(objects, list):
+        return by_card_id
+
+    for obj in objects:
+        if not isinstance(obj, dict):
+            continue
+
+        raw_card_id = obj.get('CardID')
+        try:
+            card_id = int(raw_card_id)
+        except (TypeError, ValueError):
+            card_id = None
+
+        if card_id is not None:
+            by_card_id[card_id].append({
+                'guid': str(obj.get('GUID', '')).strip(),
+                'nickname': str(obj.get('Nickname', '')).strip(),
+                'description': str(obj.get('Description', '')).strip(),
+                'gmNotes': str(obj.get('GMNotes', '')).strip(),
+            })
+
+        children = obj.get('ContainedObjects')
+        if isinstance(children, list):
+            _collect_card_metadata(children, by_card_id)
+
+    return by_card_id
+
+def _consolidate_cards(cards: list) -> list:
+    """Collapse duplicate card definitions into one entry with count/guids."""
+    grouped = {}
+    for card in cards:
+        key = (
+            card.get('id'),
+            card.get('nickname', ''),
+            card.get('faceURLId'),
+            card.get('row'),
+            card.get('column'),
+            card.get('description', ''),
+            card.get('gmNotes', ''),
+        )
+
+        if key not in grouped:
+            grouped[key] = {
+                'id': card.get('id'),
+                'nickname': card.get('nickname', ''),
+                'faceURLId': card.get('faceURLId'),
+                'row': card.get('row'),
+                'column': card.get('column'),
+                'description': card.get('description', ''),
+                'gmNotes': card.get('gmNotes', ''),
+                'count': 0,
+                'guids': [],
+            }
+
+        grouped[key]['count'] += 1
+        guid = str(card.get('guid', '')).strip()
+        if guid and guid not in grouped[key]['guids']:
+            grouped[key]['guids'].append(guid)
+
+    consolidated = list(grouped.values())
+    consolidated.sort(key=lambda c: (c['faceURLId'], c['row'], c['column']))
+    return consolidated
+
+def extract_deck_cards(deck_obj: dict) -> tuple[dict, dict, list]:
+    """Build per-deck URL metadata and card positions for deck/card objects."""
+    custom_deck = deck_obj.get('CustomDeck')
+    if not isinstance(custom_deck, dict):
+        return {}, {}, []
+
+    face_meta_by_id = {}
+    back_urls_by_id = {}
+    deck_width_by_id = {}
+
+    for deck_key, deck_def in custom_deck.items():
+        if not isinstance(deck_def, dict):
+            continue
+
+        num_width = deck_def.get('NumWidth')
+        num_height = deck_def.get('NumHeight')
+        if isinstance(num_width, int) and num_width > 0:
+            deck_width_by_id[str(deck_key)] = num_width
+
+        face_url = deck_def.get('FaceURL')
+        if (
+            isinstance(face_url, str)
+            and face_url.strip()
+            and isinstance(num_width, int)
+            and num_width > 0
+            and isinstance(num_height, int)
+            and num_height > 0
+        ):
+            face_meta_by_id[str(deck_key)] = {
+                'url': face_url.strip(),
+                'numWidth': num_width,
+                'numHeight': num_height,
+            }
+
+        back_url = deck_def.get('BackURL')
+        if isinstance(back_url, str) and back_url.strip():
+            back_urls_by_id[str(deck_key)] = back_url.strip()
+
+    cards = []
+    card_ids = []
+    if isinstance(deck_obj.get('DeckIDs'), list):
+        card_ids.extend(deck_obj['DeckIDs'])
+    if deck_obj.get('CardID') not in (None, ''):
+        card_ids.append(deck_obj['CardID'])
+
+    metadata_by_card_id = _collect_card_metadata(deck_obj.get('ContainedObjects', []))
+    root_card_id = deck_obj.get('CardID')
+    try:
+        root_card_id_int = int(root_card_id)
+    except (TypeError, ValueError):
+        root_card_id_int = None
+    if root_card_id_int is not None:
+        metadata_by_card_id[root_card_id_int].insert(0, {
+            'guid': str(deck_obj.get('GUID', '')).strip(),
+            'nickname': str(deck_obj.get('Nickname', '')).strip(),
+            'description': str(deck_obj.get('Description', '')).strip(),
+            'gmNotes': str(deck_obj.get('GMNotes', '')).strip(),
+        })
+
+    metadata_cursor_by_card_id = defaultdict(int)
+
+    for raw_id in card_ids:
+        try:
+            card_id = int(raw_id)
+        except (TypeError, ValueError):
+            continue
+
+        local_id = card_id % 100
+        deck_key = str(card_id // 100)
+        num_width = deck_width_by_id.get(deck_key)
+        if not isinstance(num_width, int) or num_width <= 0:
+            if len(deck_width_by_id) == 1:
+                num_width = next(iter(deck_width_by_id.values()))
+            else:
+                continue
+
+        meta_items = metadata_by_card_id.get(card_id, [])
+        meta_index = metadata_cursor_by_card_id[card_id]
+        if meta_index < len(meta_items):
+            card_meta = meta_items[meta_index]
+            metadata_cursor_by_card_id[card_id] += 1
+        else:
+            card_meta = {
+                'guid': '',
+                'nickname': '',
+                'description': '',
+                'gmNotes': '',
+            }
+
+        cards.append({
+            'id': card_id,
+            'nickname': card_meta['nickname'],
+            'faceURLId': int(deck_key),
+            'row': local_id // num_width,
+            'column': local_id % num_width,
+            'guid': card_meta['guid'],
+            'description': card_meta['description'],
+            'gmNotes': card_meta['gmNotes'],
+        })
+
+    cards = _consolidate_cards(cards)
+
+    return face_meta_by_id, back_urls_by_id, cards
+
+def _cards_signature(face_payload, back_payload):
+    """Stable signature for grouping cards that share deck assets."""
+    return json.dumps(
+        {
+            'FaceURL': face_payload or {},
+            'BackURL': back_payload or {},
+        },
+        ensure_ascii=False,
+        sort_keys=True,
+    )
+
+def collect_nickname_assets(objects, grouped=None, cards_group_index=None, parent_label=''):
+    """Collect asset URLs grouped by nickname, merging cards by shared deck assets."""
+    if grouped is None:
+        grouped = {}
+    if cards_group_index is None:
+        cards_group_index = {}
+
+    if not isinstance(objects, list):
+        return grouped
+
+    for obj in objects:
+        if not isinstance(obj, dict):
+            continue
+
+        nickname = str(obj.get('Nickname', '')).strip()
+        name = str(obj.get('Name', '')).strip()
+        guid = str(obj.get('GUID', '')).strip()
+        label = nickname or parent_label or (name if name and name != 'Card' else '')
+
+        object_urls = extract_urls_for_object(obj)
+        url_payload = _simplify_url_fields(object_urls)
+        custom_pdf_info = _extract_custom_pdf_info(obj)
+        face_meta_by_id, back_urls_by_id, cards = extract_deck_cards(obj)
+
+        if custom_pdf_info:
+            url_payload['CustomPDF'] = custom_pdf_info
+
+        if face_meta_by_id:
+            # Keep mapping stable by numeric deck ID order.
+            url_payload['FaceURL'] = {
+                deck_id: face_meta_by_id[deck_id]
+                for deck_id in sorted(face_meta_by_id.keys(), key=_deck_key_sort_value)
+            }
+
+        if back_urls_by_id:
+            # Decks may have different card backs across deck IDs.
+            url_payload['BackURL'] = _simplify_back_url_map(back_urls_by_id)
+
+        if cards:
+            entry = dict(url_payload)
+            entry['Cards'] = cards
+            signature = _cards_signature(entry.get('FaceURL'), entry.get('BackURL'))
+            existing_key = cards_group_index.get(signature)
+
+            if existing_key and isinstance(grouped.get(existing_key), dict):
+                grouped[existing_key]['Cards'].extend(cards)
+                grouped[existing_key]['Cards'] = _consolidate_cards(
+                    grouped[existing_key]['Cards']
+                )
+            else:
+                key = label or (name if name and name != 'Card' else f"Deck {signature[:8]}")
+                if key in grouped:
+                    key = f"{key} ({guid})" if guid else f"{key} ({len(grouped) + 1})"
+                grouped[key] = entry
+                cards_group_index[signature] = key
+        elif label:
+            if len(url_payload) == 1:
+                entry = next(iter(url_payload.values()))
+            elif url_payload:
+                entry = url_payload
+            else:
+                entry = None
+
+            if entry is not None:
+                key = label
+                if key in grouped:
+                    key = f"{label} ({guid})" if guid else f"{label} ({len(grouped) + 1})"
+                grouped[key] = entry
+
+        children = obj.get('ContainedObjects')
+        has_deck_ids = isinstance(obj.get('DeckIDs'), list) and len(obj.get('DeckIDs')) > 0
+        if isinstance(children, list) and not has_deck_ids:
+            collect_nickname_assets(
+                children,
+                grouped,
+                cards_group_index,
+                label,
+            )
+
+        states = obj.get('States')
+        if isinstance(states, dict):
+            collect_nickname_assets(
+                list(states.values()),
+                grouped,
+                cards_group_index,
+                label,
+            )
+
+    return grouped
+
+
+# \u2500\u2500\u2500 Lua / XML script extraction \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+SCRIPT_FIELD_NAMES = {'LuaScript', 'LuaScriptState', 'XmlUI'}
+
+def extract_scripts(obj, scripts=None, path=''):
+    """
+    Walk the tree and collect every non-empty script / XML string along with
+    context (GUID, Name, Nickname).
+    """
+    if scripts is None:
+        scripts = []
+
+    if isinstance(obj, dict):
+        guid     = obj.get('GUID',     '')
+        name     = obj.get('Name',     '')
+        nickname = obj.get('Nickname', '')
+
+        for field in SCRIPT_FIELD_NAMES:
+            v = obj.get(field, '')
+            if isinstance(v, str) and v.strip():
+                scripts.append({
+                    'field':    field,
+                    'guid':     guid,
+                    'name':     name,
+                    'nickname': nickname,
+                    'path':     path,
+                    'content':  v,
+                })
+
+        for k, v in obj.items():
+            if isinstance(v, (dict, list)):
+                extract_scripts(v, scripts, f"{path}.{k}" if path else k)
+
+    elif isinstance(obj, list):
+        for i, item in enumerate(obj):
+            extract_scripts(item, scripts, f"{path}[{i}]")
+
+    return scripts
+
+
+# \u2500\u2500\u2500 Object summariser \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+# Fields that are interesting but don't need deep inspection
+OBJECT_SCALAR_FIELDS = {
+    'GUID', 'Name', 'Nickname', 'Description', 'GMNotes',
+    'FogColor', 'Locked', 'Snap', 'Grid',
+    'HideWhenFaceDown', 'Hands',
+    'CardID', 'SidewaysCard', 'DeckIDs',
+    'Value', 'LayoutGroupSortIndex',
+}
+
+# Sub-objects we want to keep verbatim (they hold asset info)
+CUSTOM_SECTIONS = {
+    'CustomImage', 'CustomMesh', 'CustomDeck',
+    'CustomAssetbundle', 'CustomPDF',
+    'Transform',
+}
+
+def summarise_object(obj):
+    """
+    Return a lightweight, human-readable summary of one TTS object.
+    Large script bodies are replaced with a presence flag.
+    """
+    if not isinstance(obj, dict):
+        return obj
+
+    summary = {}
+
+    for k in OBJECT_SCALAR_FIELDS:
+        v = obj.get(k)
+        if v not in (None, '', 0, False, []):
+            summary[k] = v
+
+    for k in CUSTOM_SECTIONS:
+        if k in obj:
+            summary[k] = obj[k]
+
+    for sk in SCRIPT_FIELD_NAMES:
+        v = obj.get(sk, '')
+        if isinstance(v, str) and v.strip():
+            summary[f'{sk}_present'] = True
+
+    # Recurse into child-object containers
+    for container in ('ContainedObjects', 'States'):
+        v = obj.get(container)
+        if isinstance(v, list):
+            summary[container] = [summarise_object(o) for o in v]
+        elif isinstance(v, dict):
+            summary[container] = {k2: summarise_object(v2) for k2, v2 in v.items()}
+
+    return summary
+
+
+# \u2500\u2500\u2500 Script file writer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+def safe_filename(text: str, maxlen: int = 50) -> str:
+    return re.sub(r'[^\\w\\-]', '_', text)[:maxlen]
+
+
+def write_scripts(scripts: list, out_dir: Path):
+    """
+    Deduplicate and write each unique script body to a file.
+    Returns the index list (content replaced by file path).
+    """
+    lua_dir = out_dir / 'scripts'
+    lua_dir.mkdir(exist_ok=True)
+
+    seen_content: dict[str, str] = {}   # content \u2192 relative file path
+    index = []
+
+    for s in scripts:
+        content = s['content']
+        field   = s['field']
+
+        if content in seen_content:
+            entry = {k: v for k, v in s.items() if k != 'content'}
+            entry['file'] = seen_content[content]
+            index.append(entry)
+            continue
+
+        ext   = '.xml' if field == 'XmlUI' else '.lua'
+        label = s['nickname'] or s['name'] or s['guid'] or 'unknown'
+        base  = f"{s['guid']}_{safe_filename(label)}" if s['guid'] else safe_filename(label)
+        fpath = lua_dir / f"{base}{ext}"
+
+        n = 1
+        while fpath.exists():
+            fpath = lua_dir / f"{base}_{n}{ext}"
+            n += 1
+
+        fpath.write_text(content, encoding='utf-8')
+        rel = str(fpath.relative_to(out_dir))
+        seen_content[content] = rel
+
+        entry = {k: v for k, v in s.items() if k != 'content'}
+        entry['file'] = rel
+        index.append(entry)
+
+    return index, lua_dir
+
+
+# \u2500\u2500\u2500 Full-save JSON (with scripts stripped) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+def strip_script_bodies(obj, threshold: int = 80):
+    """Replace long script strings with a placeholder so the JSON stays sane."""
+    if isinstance(obj, dict):
+        return {
+            k: (f'<{k}: {len(v)} chars>'
+                if k in SCRIPT_FIELD_NAMES and isinstance(v, str) and len(v) > threshold
+                else strip_script_bodies(v))
+            for k, v in obj.items()
+        }
+    if isinstance(obj, list):
+        return [strip_script_bodies(i) for i in obj]
+    return obj
+
+
+# \u2500\u2500\u2500 steamcmd workshop downloader \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+TTS_APP_ID = '286160'
+WORKSHOP_CONTENT_DIR = (
+    Path.home() / 'Library' / 'Application Support' / 'Steam'
+    / 'steamapps' / 'workshop' / 'content' / TTS_APP_ID
+)
+
+# Candidate locations for steamcmd, checked in order:
+#   1. Anywhere on PATH  (e.g. \`brew install --cask steamcmd\`)
+#   2. Manual install next to this script  (../steamcmd.sh)
+def _find_steamcmd() -> str | None:
+    import shutil
+    return shutil.which('steamcmd')
+
+
+def download_workshop_item(workshop_id: str) -> Path:
+    """
+    Download a TTS Steam Workshop item via steamcmd and return the path to the
+    .bin file inside the downloaded directory.
+
+    Raises SystemExit on failure.
+    """
+    steamcmd = _find_steamcmd()
+    if not steamcmd:
+        print("Error: steamcmd not found.", file=sys.stderr)
+        print("  Install it with:  brew install --cask steamcmd", file=sys.stderr)
+        print("  Or manually:      https://developer.valvesoftware.com/wiki/SteamCMD",
+              file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Downloading Workshop item {workshop_id} (app {TTS_APP_ID}) \u2026")
+    print(f"  Using steamcmd: {steamcmd}")
+
+    result = subprocess.run(
+        [
+            steamcmd,
+            '+login', 'anonymous',
+            '+workshop_download_item', TTS_APP_ID, workshop_id,
+            '+quit',
+        ],
+        text=True,
+        capture_output=False,   # let steamcmd print progress to the terminal
+    )
+
+    if result.returncode != 0:
+        print(f"Error: steamcmd exited with code {result.returncode}.", file=sys.stderr)
+        sys.exit(result.returncode)
+
+    item_dir = WORKSHOP_CONTENT_DIR / workshop_id
+    if not item_dir.exists():
+        print(f"Error: expected download directory not found: {item_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    bins = sorted(item_dir.glob('*.bin'))
+    if not bins:
+        print(f"Error: no .bin file found in {item_dir}", file=sys.stderr)
+        print(f"  Directory contents: {list(item_dir.iterdir())}", file=sys.stderr)
+        sys.exit(1)
+
+    if len(bins) > 1:
+        print(f"  Multiple .bin files found; using the largest: {bins}")
+        bins.sort(key=lambda p: p.stat().st_size, reverse=True)
+
+    return bins[0]
+
+
+def parse_workshop_id(input_value: str) -> str | None:
+    """Return a Workshop ID from a raw ID or Steam workshop URL."""
+    trimmed = input_value.strip()
+    if trimmed.isdigit():
+        return trimmed
+
+    parsed = urlparse(trimmed)
+    if parsed.scheme in {'http', 'https'} and parsed.netloc.endswith('steamcommunity.com'):
+        query_match = re.search(r'(?:^|[?&])id=(\\d+)(?:&|$)', parsed.query)
+        if query_match:
+            return query_match.group(1)
+
+        path_match = re.search(r'/sharedfiles/filedetails/(\\d+)', parsed.path)
+        if path_match:
+            return path_match.group(1)
+
+    return None
+
+
+# \u2500\u2500\u2500 Helpers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+def slugify(name: str) -> str:
+    """
+    Convert a save name into a safe directory name:
+      - spaces \u2192 hyphens
+      - characters illegal in file/dir names stripped
+      - collapse runs of hyphens
+      - strip leading/trailing hyphens
+    """
+    # Characters that are unsafe on macOS/Linux/Windows
+    slug = re.sub(r'[/\\\\:*?"<>|]', '', name)
+    slug = slug.replace(' ', '-')
+    slug = re.sub(r'-{2,}', '-', slug)
+    slug = slug.strip('-')
+    return slug or 'untitled'
+
+def is_http_url(value) -> bool:
+    return isinstance(value, str) and value.startswith(('http://', 'https://'))
+
+def collect_asset_urls(obj, path=(), collected=None):
+    """Collect unique asset URLs and their first-seen field path."""
+    if collected is None:
+        collected = {}
+
+    if is_http_url(obj):
+        collected.setdefault(obj, path)
+        return collected
+
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            collect_asset_urls(v, path + (str(k),), collected)
+    elif isinstance(obj, list):
+        for i, item in enumerate(obj):
+            collect_asset_urls(item, path + (str(i),), collected)
+
+    return collected
+
+def infer_asset_subdir(path: tuple[str, ...]) -> str:
+    """Infer an asset sub-folder from a URL's JSON field path."""
+    fields = [p.lower() for p in path if not p.isdigit()]
+
+    if 'custompdf' in fields or 'pdfurl' in fields:
+        return 'pdf'
+    if 'faceurl' in fields or 'backurl' in fields:
+        return 'deck'
+    if 'meshurl' in fields or 'colliderurl' in fields:
+        return 'mesh'
+    if 'assetbundleurl' in fields or 'assetbundlesecondaryurl' in fields:
+        return 'assetbundle'
+    if (
+        'imageurl' in fields
+        or 'imagesecondaryurl' in fields
+        or 'diffuseurl' in fields
+        or 'normalurl' in fields
+    ):
+        return 'image'
+    if 'tableurl' in fields or 'skyurl' in fields:
+        return 'environment'
+    return 'misc'
+
+def guess_extension(url: str, content_type: str, subdir: str) -> str:
+    """Guess a file extension from URL/content-type with sensible fallbacks."""
+    parsed = urlparse(url)
+    suffix = Path(parsed.path).suffix.lower()
+    if 1 <= len(suffix) <= 8 and re.fullmatch(r'\\.[a-z0-9]+', suffix):
+        return suffix
+
+    ctype = (content_type or '').split(';', 1)[0].strip().lower()
+    mapped = {
+        'application/pdf': '.pdf',
+        'image/jpeg': '.jpg',
+        'image/jpg': '.jpg',
+        'image/png': '.png',
+        'image/webp': '.webp',
+        'image/gif': '.gif',
+    }.get(ctype)
+    if mapped:
+        return mapped
+
+    guess = mimetypes.guess_extension(ctype) if ctype else None
+    if guess:
+        return '.jpg' if guess == '.jpe' else guess
+
+    if subdir == 'pdf':
+        return '.pdf'
+    return '.bin'
+
+def detect_extension_from_content(data: bytes):
+    """Infer extension from file signature when headers/URL are ambiguous."""
+    if data.startswith(b'%PDF-'):
+        return '.pdf'
+    return None
+
+class DownloadRateLimiter:
+    """Simple process-local token bucket equivalent (fixed interval)."""
+    def __init__(self, requests_per_second: float):
+        self.interval = 0.0 if requests_per_second <= 0 else (1.0 / requests_per_second)
+        self.lock = threading.Lock()
+        self.next_allowed = 0.0
+
+    def wait(self):
+        if self.interval <= 0:
+            return
+        with self.lock:
+            now = time.monotonic()
+            if now < self.next_allowed:
+                time.sleep(self.next_allowed - now)
+                now = time.monotonic()
+            self.next_allowed = now + self.interval
+
+def _download_single_asset(url: str, subdir: str, assets_root: Path, limiter: DownloadRateLimiter):
+    """Download one URL with retries, backoff, and atomic writes."""
+    folder = assets_root / subdir
+    folder.mkdir(parents=True, exist_ok=True)
+
+    digest = hashlib.sha1(url.encode('utf-8')).hexdigest()[:20]
+    existing = sorted(folder.glob(f'{digest}.*'))
+    if existing:
+        chosen = existing[0]
+        # Retro-fix older cached PDF downloads that were saved as .bin.
+        if chosen.suffix == '.bin' and subdir == 'pdf':
+            try:
+                header = chosen.read_bytes()[:8]
+                if detect_extension_from_content(header) == '.pdf':
+                    repaired = chosen.with_suffix('.pdf')
+                    chosen.replace(repaired)
+                    chosen = repaired
+            except Exception:
+                pass
+        return str(chosen.relative_to(assets_root.parent)), 'cached'
+
+    max_attempts = 5
+    for attempt in range(max_attempts):
+        limiter.wait()
+        try:
+            req = Request(url, headers={'User-Agent': 'tts-extractor/1.0 (+respectful downloader)'})
+            with urlopen(req, timeout=30) as resp:
+                body = resp.read()
+                content_type = resp.headers.get('Content-Type', '')
+            ext = guess_extension(url, content_type, subdir)
+            detected_ext = detect_extension_from_content(body[:16])
+            if detected_ext:
+                ext = detected_ext
+            dest = folder / f'{digest}{ext}'
+            tmp = folder / f'{digest}{ext}.part'
+            tmp.write_bytes(body)
+            tmp.replace(dest)
+            return str(dest.relative_to(assets_root.parent)), 'downloaded'
+
+        except HTTPError as e:
+            if e.code in (429, 500, 502, 503, 504) and attempt + 1 < max_attempts:
+                retry_after = e.headers.get('Retry-After', '').strip()
+                if retry_after.isdigit():
+                    time.sleep(min(int(retry_after), 30))
+                else:
+                    time.sleep(min(2 ** attempt, 16))
+                continue
+            return None, f'HTTP {e.code}'
+
+        except URLError as e:
+            if attempt + 1 < max_attempts:
+                time.sleep(min(2 ** attempt, 16))
+                continue
+            return None, f'URL error: {e.reason}'
+
+        except Exception as e:  # noqa: BLE001
+            return None, f'Error: {e}'
+
+    return None, 'Retries exhausted'
+
+def map_urls_to_files(obj, url_to_file: dict):
+    """Deep-copy an asset structure replacing URLs with local relative paths."""
+    if is_http_url(obj):
+        return url_to_file.get(obj, obj)
+    if isinstance(obj, dict):
+        return {k: map_urls_to_files(v, url_to_file) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [map_urls_to_files(i, url_to_file) for i in obj]
+    return obj
+
+def download_assets(asset_urls: dict, out_dir: Path, workers: int, requests_per_second: float):
+    """Download all URLs referenced by asset_urls and return URL\u2192file mapping."""
+    assets_root = out_dir / 'assets'
+    assets_root.mkdir(parents=True, exist_ok=True)
+
+    url_context = collect_asset_urls(asset_urls)
+    if not url_context:
+        return {}, {}
+
+    limiter = DownloadRateLimiter(requests_per_second)
+    url_to_file: dict[str, str] = {}
+    failures: dict[str, str] = {}
+
+    worker_count = max(1, min(workers, 16))
+    with ThreadPoolExecutor(max_workers=worker_count) as executor:
+        futures = {}
+        for url, path in url_context.items():
+            subdir = infer_asset_subdir(path)
+            fut = executor.submit(_download_single_asset, url, subdir, assets_root, limiter)
+            futures[fut] = url
+
+        for fut in as_completed(futures):
+            url = futures[fut]
+            rel_path, status = fut.result()
+            if rel_path:
+                url_to_file[url] = rel_path
+            else:
+                failures[url] = status
+
+    return url_to_file, failures
+
+
+# \u2500\u2500\u2500 Main \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Extract Tabletop Simulator binary saves and optionally download assets.'
+    )
+    parser.add_argument('input', help='Path to .bin save, Steam Workshop ID, or Workshop URL')
+    parser.add_argument('output_dir', nargs='?', help='Output directory (default: save-name folder)')
+    parser.add_argument(
+        '--download',
+        action='store_true',
+        help='Download assets from asset_urls.json into assets/ and emit asset_files.json',
+    )
+    parser.add_argument(
+        '--download-workers',
+        type=int,
+        default=6,
+        help='Maximum concurrent download workers (default: 6, capped at 16)',
+    )
+    parser.add_argument(
+        '--download-rps',
+        type=float,
+        default=3.0,
+        help='Global request rate limit in requests/second across all workers (default: 3.0)',
+    )
+    args = parser.parse_args()
+
+    arg = args.input
+
+    # \u2500\u2500 Mode detection \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    # Numeric IDs and full Steam workshop URLs are treated as workshop inputs.
+    # Everything else is treated as a path to a local .bin file.
+    workshop_id = parse_workshop_id(arg)
+    if workshop_id is not None:
+        bin_path = download_workshop_item(workshop_id)
+        print(f"  Found: {bin_path}")
+        base_dir = Path.cwd()
+    else:
+        bin_path = Path(arg)
+        if not bin_path.exists():
+            print(f"Error: '{bin_path}' not found.", file=sys.stderr)
+            sys.exit(1)
+        base_dir = bin_path.parent
+
+    # \u2500\u2500 Parse \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    print(f"Parsing {bin_path.name}  ({bin_path.stat().st_size:,} bytes) \u2026")
+    data = bin_path.read_bytes()
+
+    # Verify magic header  (e1 66 04 00)
+    magic = data[:4]
+    if magic != b'\\xe1\\x66\\x04\\x00':
+        print(f"  [INFO] Unexpected header bytes: {magic.hex()} "
+              "(continuing anyway)", file=sys.stderr)
+
+    root = parse_records(data, HEADER_SIZE, len(data))
+    print(f"  Parsed {len(root)} top-level keys.")
+
+    # \u2500\u2500 Resolve output directory \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    if args.output_dir:
+        out_dir = Path(args.output_dir)
+    else:
+        save_name = root.get('SaveName', '').strip()
+        dir_name = slugify(save_name) if save_name else slugify(bin_path.stem)
+        out_dir = base_dir / dir_name
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # \u2500\u2500 1. Metadata \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    META_KEYS = [
+        'SaveName', 'EpochTime', 'Date', 'VersionNumber',
+        'GameMode', 'GameType', 'GameComplexity',
+        'PlayingTime', 'PlayerCounts', 'Tags',
+        'Table', 'TableURL', 'Sky', 'SkyURL',
+        'Note', 'Gravity', 'PlayArea',
+    ]
+    metadata = {k: root[k] for k in META_KEYS if k in root}
+
+    meta_path = out_dir / 'metadata.json'
+    meta_path.write_text(json.dumps(metadata, indent=2, ensure_ascii=False),
+                         encoding='utf-8')
+    print(f"\\n[1] Metadata \u2192 {meta_path.name}")
+    print(f"    Save: {metadata.get('SaveName', '?')}  |  "
+          f"Date: {metadata.get('Date', '?')}  |  "
+          f"Version: {metadata.get('VersionNumber', '?')}")
+
+    # \u2500\u2500 2. Asset URLs \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    urls_by_field = extract_urls(root)
+    all_urls_sorted = sorted({u for vs in urls_by_field.values() for u in vs})
+    nickname_assets = collect_nickname_assets(root.get('ObjectStates', []))
+
+    url_json_path = out_dir / 'asset_urls.json'
+    url_json_path.write_text(
+        json.dumps(nickname_assets, indent=2, ensure_ascii=False),
+        encoding='utf-8'
+    )
+
+    url_txt_path = out_dir / 'asset_urls.txt'
+    url_txt_path.write_text('\\n'.join(all_urls_sorted), encoding='utf-8')
+
+    print(f"\\n[2] Asset URLs \u2192 {url_json_path.name}  ({url_txt_path.name})")
+    print(f"    Nicknames captured: {len(nickname_assets)}")
+    for field, vs in sorted(urls_by_field.items()):
+        print(f"    {field:30s}: {len(vs)} URL(s)")
+    print(f"    {'TOTAL unique':30s}: {len(all_urls_sorted)}")
+
+    if args.download:
+        url_to_file, failures = download_assets(
+            nickname_assets,
+            out_dir,
+            workers=args.download_workers,
+            requests_per_second=max(args.download_rps, 0.1),
+        )
+        asset_files = map_urls_to_files(nickname_assets, url_to_file)
+        asset_files_path = out_dir / 'asset_files.json'
+        asset_files_path.write_text(
+            json.dumps(asset_files, indent=2, ensure_ascii=False),
+            encoding='utf-8',
+        )
+
+        print(f"\\n[2b] Downloaded assets \u2192 assets/  ({asset_files_path.name})")
+        print(f"    Downloaded files: {len(url_to_file)} / {len(collect_asset_urls(nickname_assets))}")
+        if failures:
+            print(f"    Failed: {len(failures)} URL(s)")
+            for url, reason in sorted(failures.items())[:5]:
+                print(f"      - {reason}: {url}")
+
+    # \u2500\u2500 3. Scripts \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    # Global scripts (root-level)
+    global_scripts = []
+    for field in SCRIPT_FIELD_NAMES:
+        v = root.get(field, '')
+        if isinstance(v, str) and v.strip():
+            global_scripts.append({'field': field, 'guid': '', 'name': 'GLOBAL',
+                                   'nickname': '', 'path': '', 'content': v})
+
+    # All scripts from the object tree
+    all_scripts = global_scripts + extract_scripts(root.get('ObjectStates', []),
+                                                   path='ObjectStates')
+
+    script_index, lua_dir = write_scripts(all_scripts, out_dir)
+
+    index_path = out_dir / 'scripts_index.json'
+    index_path.write_text(json.dumps(script_index, indent=2, ensure_ascii=False),
+                          encoding='utf-8')
+
+    lua_count = sum(1 for s in script_index if s['field'] == 'LuaScript')
+    xml_count = sum(1 for s in script_index if s['field'] == 'XmlUI')
+    state_count = sum(1 for s in script_index if s['field'] == 'LuaScriptState')
+    print(f"\\n[3] Scripts \u2192 {lua_dir.relative_to(out_dir)}/")
+    print(f"    LuaScript: {lua_count}  |  XmlUI: {xml_count}  |  "
+          f"LuaScriptState: {state_count}")
+
+    # \u2500\u2500 4. Object summaries \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    objects = root.get('ObjectStates', [])
+    summaries = [summarise_object(o) for o in objects]
+
+    obj_path = out_dir / 'objects.json'
+    obj_path.write_text(json.dumps(summaries, indent=2, ensure_ascii=False),
+                        encoding='utf-8')
+
+    # Count by object type
+    type_counts: dict[str, int] = defaultdict(int)
+    def count_types(obj_list):
+        for o in obj_list:
+            if isinstance(o, dict):
+                type_counts[o.get('Name', 'Unknown')] += 1
+                count_types(o.get('ContainedObjects') or [])
+    count_types(objects)
+
+    print(f"\\n[4] Objects \u2192 {obj_path.name}  ({len(objects)} top-level)")
+    for t, c in sorted(type_counts.items(), key=lambda x: -x[1]):
+        print(f"    {t:30s}: {c}")
+
+    # \u2500\u2500 5. Full parsed save (scripts stripped) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    stripped = strip_script_bodies(root)
+    full_path = out_dir / 'full_save.json'
+    full_path.write_text(json.dumps(stripped, indent=2, ensure_ascii=False),
+                         encoding='utf-8')
+    print(f"\\n[5] Full save JSON (scripts stripped) \u2192 {full_path.name}")
+
+    # \u2500\u2500 6. Tab states \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    tab_states = root.get('TabStates', {})
+    if tab_states:
+        tab_path = out_dir / 'tab_states.json'
+        tab_path.write_text(json.dumps(tab_states, indent=2, ensure_ascii=False),
+                            encoding='utf-8')
+        print(f"\\n[6] Tab states \u2192 {tab_path.name}  ({len(tab_states)} tabs)")
+
+    # \u2500\u2500 7. Snap points \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    snap_points = root.get('SnapPoints', [])
+    if snap_points:
+        snap_path = out_dir / 'snap_points.json'
+        snap_path.write_text(json.dumps(snap_points, indent=2, ensure_ascii=False),
+                             encoding='utf-8')
+        print(f"\\n[7] Snap points \u2192 {snap_path.name}  ({len(snap_points)} points)")
+
+    print(f"\\nAll output written to: {out_dir}/")
+
+
+if __name__ == '__main__':
+    main()
+`,
+  "SKILL.md": '---\nname: dreamboard\ndescription: Create multiplayer, rule-enforced, turn-based game on Dreamboard.games platform.\nmetadata:\n  short-description: Dreamboard Game Development Workflow\n  tags: [dreamboard, cli, game-dev, board-game, turn-based, multiplayer]\n---\n\n# Dreamboard\n\n## Goal\n\nCreate and iterate on a Dreamboard game locally, then sync rules, scaffold, UI, and tests back to the platform.\n\n## Why Dreamboard\n\nDreamboard exists to turn a board-game idea into a playable digital prototype quickly.\n\n- Describe the game instead of hand-building every primitive first.\n- Generate rules scaffolding, components, and UI structure faster.\n- Playtest with real players without repeated print-and-play friction.\n- Iterate live while Dreamboard handles turns, hands, and multiplayer plumbing.\n\n## Prereqs\n\n- Dreamboard CLI installed and available as `dreamboard`\n- Authenticated via `dreamboard login`\n\n## Core Workflow\n\n1. Create a game: `dreamboard new <slug> --description "<<short description>>"`\n2. Author `rule.md` and `manifest.json`\n3. Run `dreamboard update` after every manifest or rule change\n4. Implement rules in `app/phases/*.ts` and UI data in `shared/ui-args.ts`\n5. Implement UI in `ui/App.tsx` and `ui/components/*`\n6. Typecheck from the game root: `bun install && bun run typecheck`\n7. Push compiled changes: `dreamboard push`\n8. Generate deterministic bases: `dreamboard test generate`\n9. Run regression scenarios: `dreamboard test run`\n10. Validate the live UI with `dreamboard run --screenshot`\n\n## Choose The Right Reference\n\nRead only the reference that matches the task:\n\n- Rules and manifest:\n  [references/rule-authoring.md](references/rule-authoring.md),\n  [references/manifest-authoring.md](references/manifest-authoring.md)\n- App logic and engine concepts:\n  [references/phase-handlers.md](references/phase-handlers.md),\n  [references/api-reference.md](references/api-reference.md),\n  [references/hands-vs-decks.md](references/hands-vs-decks.md),\n  [references/all-players-tracking.md](references/all-players-tracking.md),\n  [references/app-best-practices.md](references/app-best-practices.md)\n- UI and UX:\n  [references/ui-best-practices.md](references/ui-best-practices.md),\n  [references/ui-style-guide.md](references/ui-style-guide.md),\n  genre references under `references/ui-genre-*.md`\n- TypeScript regression harness (`dreamboard test generate/run`):\n  [references/test-harness.md](references/test-harness.md)\n- JSON runtime scenarios (`dreamboard run --scenario ...`):\n  [references/scenario-format.md](references/scenario-format.md)\n- Rejection and edge-case pressure using JSON runtime scenarios:\n  [references/adversarial-testing.md](references/adversarial-testing.md)\n- TTS migration:\n  [references/tts-migration-and-extractor.md](references/tts-migration-and-extractor.md)\n\n## Testing Modes\n\nThere are two different scenario systems:\n\n- `dreamboard test generate` / `dreamboard test run`\n  TypeScript scenario files in `test/scenarios/*.scenario.ts` against deterministic generated base snapshots. Use this for regression coverage.\n- `dreamboard run --scenario path/to/file.json`\n  JSON action scripts that drive a live session. Use this for debugging flows, reproductions, and adversarial experiments.\n\nDo not mix the two formats.\n\n## UX Bar\n\nUX is part of the implementation, not polish for later.\n\n- Make turn ownership and available actions obvious without reading logs.\n- Keep round-resolution and game-over feedback visible long enough for a player to perceive it.\n- Use `dreamboard run --screenshot` to verify initial state, active player, round resolution, and game-over feedback on realistic viewport sizes.\n\n## Guardrails\n\n- `manifest.json` and `rule.md` are the source of truth for scaffolding.\n- Run `dreamboard update` after manifest changes to keep generated files in sync.\n- `dreamboard update` is local-first and fails when remote drift is detected.\n- Use `dreamboard update --pull` only when you explicitly need to reconcile unexpected remote changes into the workspace.\n- `dreamboard test generate` should be re-run after base changes, compiled-result changes, or game identity changes.\n- Add at least one zero-step `initial-state` scenario so setup invariants fail before action tests begin.\n- Keep `scripts/events-extract.mjs` as a debugging helper for `.dreamboard/run/events.ndjson`; assertions belong in test scenarios.\n\n## Editable Surface\n\nEdit:\n\n- `app/phases/*.ts`\n- `shared/ui-args.ts`\n- `ui/App.tsx`\n- `ui/components/*`\n- `ui/sdk/components/*`\n\nDo not edit framework-owned files such as:\n\n- `app/index.ts`\n- `app/sdk/*`\n- `app/generated/*`\n- `ui/index.tsx`\n- `ui/sdk/context/*`\n- `ui/sdk/hooks/*`\n- `ui/sdk/types/*`\n\n## Framework Feedback\n\nUse `feedback.md` in the game project root to record framework issues, missing features, or workflow friction. Include reproduction steps, expected behavior, and actual behavior when possible.\n'
+};
+var SKILL_MD_CONTENT = SKILL_ASSET_FILES["SKILL.md"];
+
+// src/utils/fs.ts
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function installSkillFile(projectRoot) {
+  const skillRoot = path.join(projectRoot, ".agents", "skills", "dreamboard");
+  for (const [relativePath, content] of Object.entries(SKILL_ASSET_FILES)) {
+    const targetPath = path.join(skillRoot, relativePath);
+    await ensureDir(path.dirname(targetPath));
+    await writeFile(targetPath, content, "utf8");
+  }
+}
+async function exists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readTextFile(filePath) {
+  return readFile(filePath, "utf8");
+}
+async function readTextFileIfExists(filePath) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function writeTextFile(filePath, content) {
+  await ensureDir(path.dirname(filePath));
+  await writeFile(filePath, content, "utf8");
+}
+async function readJsonFile(filePath) {
+  const data = await readTextFile(filePath);
+  return JSON.parse(data);
+}
+async function writeJsonFile(filePath, data) {
+  await writeTextFile(filePath, `${JSON.stringify(data, null, 2)}
+`);
+}
+
+// src/utils/crypto.ts
+import crypto from "crypto";
+function hashContent(content) {
+  return crypto.createHash("sha256").update(content, "utf8").digest("hex");
+}
+function getUserIdFromToken(token) {
+  const [, payload] = token.split(".");
+  if (!payload) throw new Error("Invalid auth token.");
+  const decoded = JSON.parse(
+    Buffer.from(payload, "base64").toString("utf8")
+  );
+  if (!decoded.sub) throw new Error("Auth token missing user id.");
+  return decoded.sub;
+}
+
+// src/services/project/local-files.ts
+import { readdir, unlink } from "fs/promises";
+import path2 from "path";
+
+// src/constants.ts
+var DEFAULT_API_BASE_URL = "https://api.dreamboard.games";
+var DEFAULT_WEB_BASE_URL = "https://dreamboard.games";
+var CODE_EDITS_BUCKET = "code-edits";
+var PROJECT_DIR_NAME = ".dreamboard";
+var ENVIRONMENT_CONFIGS = {
+  local: {
+    apiBaseUrl: "http://localhost:8080",
+    webBaseUrl: "http://localhost:5173",
+    supabaseUrl: "http://127.0.0.1:54321",
+    supabaseAnonKey: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6ImFub24iLCJleHAiOjE5ODM4MTI5OTZ9.CRXP1A7WOeoJeXxjNni43kdQwgnWNReilDMblYTn_I0"
+  },
+  dev: {
+    apiBaseUrl: "https://dev-dreamboard.fly.dev",
+    webBaseUrl: "https://dev.dreamboard.games",
+    supabaseUrl: "https://dev-supabase.dreamboard.games",
+    supabaseAnonKey: process.env.SUPABASE_DEV_ANON_KEY || ""
+  },
+  prod: {
+    apiBaseUrl: "https://api.dreamboard.games",
+    webBaseUrl: "https://dreamboard.games",
+    supabaseUrl: "https://supabase.dreamboard.games",
+    supabaseAnonKey: process.env.SUPABASE_PROD_ANON_KEY || ""
+  }
+};
+var PROJECT_CONFIG_FILE = "project.json";
+var SNAPSHOT_FILE = "snapshot.json";
+var MANIFEST_FILE = "manifest.json";
+var RULE_FILE = "rule.md";
+var DEFAULT_LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
+var DEFAULT_TURN_DELAY_MS = 250;
+var LOCAL_IGNORE_DIRS = /* @__PURE__ */ new Set([
+  ".dreamboard",
+  ".git",
+  "node_modules",
+  "dist"
+]);
+
+// src/services/project/scaffold-ownership.generated.ts
+var SCAFFOLD_OWNERSHIP = {
+  version: 2,
+  allowedPaths: {
+    rootFiles: ["package.json", "manifest.json", "rule.md"],
+    directoryPrefixes: ["app/", "ui/", "shared/", "test/"]
+  },
+  dynamic: {
+    generatedFiles: [
+      "shared/manifest.ts",
+      "app/generated/guards.ts",
+      "app/index.ts"
+    ],
+    seedFiles: ["shared/ui-args.ts", "ui/App.tsx"],
+    seedFilePatterns: [
+      {
+        prefix: "app/phases/",
+        suffix: ".ts"
+      }
+    ]
+  },
+  cliStatic: {
+    exactFiles: [
+      "package.json",
+      "shared/game-message.d.ts",
+      "shared/index.ts",
+      "app/tsconfig.json",
+      "ui/index.tsx",
+      "ui/tsconfig.json",
+      "ui/package.json"
+    ],
+    directoryPrefixes: ["app/sdk/", "ui/sdk/"]
+  },
+  preservedUserFiles: ["shared/ui-args.ts"]
+};
+
+// src/services/project/scaffold-ownership.ts
+function normalizeProjectPath(filePath) {
+  return filePath.replace(/^\.\//, "").replace(/^\/+/, "").replace(/\\/g, "/");
+}
+function isAllowedGamePath(filePath) {
+  const path3 = normalizeProjectPath(filePath);
+  if (SCAFFOLD_OWNERSHIP.allowedPaths.rootFiles.includes(path3)) return true;
+  return SCAFFOLD_OWNERSHIP.allowedPaths.directoryPrefixes.some(
+    (prefix) => path3.startsWith(prefix)
+  );
+}
+function isDynamicGeneratedPath(filePath) {
+  const path3 = normalizeProjectPath(filePath);
+  return SCAFFOLD_OWNERSHIP.dynamic.generatedFiles.includes(path3);
+}
+function isDynamicSeedPath(filePath) {
+  const path3 = normalizeProjectPath(filePath);
+  if (SCAFFOLD_OWNERSHIP.dynamic.seedFiles.includes(path3)) return true;
+  return SCAFFOLD_OWNERSHIP.dynamic.seedFilePatterns.some(
+    (pattern) => path3.startsWith(pattern.prefix) && path3.endsWith(pattern.suffix)
+  );
+}
+function isCliStaticPath(filePath) {
+  const path3 = normalizeProjectPath(filePath);
+  if (SCAFFOLD_OWNERSHIP.cliStatic.exactFiles.includes(path3)) return true;
+  return SCAFFOLD_OWNERSHIP.cliStatic.directoryPrefixes.some(
+    (prefix) => path3.startsWith(prefix)
+  );
+}
+function isLibraryPath(filePath) {
+  return isDynamicGeneratedPath(filePath) || isCliStaticPath(filePath);
+}
+var PRESERVED_USER_FILES = new Set(
+  SCAFFOLD_OWNERSHIP.preservedUserFiles
+);
+
+// src/services/project/local-files.ts
+function isAllowedGamePath2(filePath) {
+  return isAllowedGamePath(filePath);
+}
+function isLibraryPath2(filePath) {
+  return isLibraryPath(filePath);
+}
+function shouldWriteScaffoldFile(filePath, existingContent) {
+  if (isLibraryPath2(filePath)) return "write";
+  const hasContent = existingContent !== null && existingContent.trim().length > 0;
+  return hasContent ? "skip" : "write";
+}
+async function writeSourceFiles(rootDir, files) {
+  for (const [relativePath, content] of Object.entries(files)) {
+    if (content === null || content === void 0) continue;
+    const filePath = path2.join(rootDir, relativePath);
+    await writeTextFile(filePath, content);
+  }
+}
+async function writeScaffoldFiles(rootDir, files) {
+  const written = [];
+  const skipped = [];
+  for (const [relativePath, content] of Object.entries(files)) {
+    if (content === null || content === void 0) continue;
+    const fullPath = path2.join(rootDir, relativePath);
+    const existingContent = await readTextFileIfExists(fullPath);
+    const decision = shouldWriteScaffoldFile(relativePath, existingContent);
+    if (decision === "skip") {
+      skipped.push(relativePath);
+      continue;
+    }
+    await writeTextFile(fullPath, content);
+    if (existingContent !== content) {
+      written.push(relativePath);
+    }
+  }
+  written.sort();
+  skipped.sort();
+  return { written, skipped };
+}
+async function removeExtraneousFiles(rootDir, keep) {
+  const localFiles = await collectLocalFiles(rootDir);
+  for (const filePath of Object.keys(localFiles)) {
+    if (filePath === MANIFEST_FILE || filePath === RULE_FILE) continue;
+    if (!keep.has(filePath)) {
+      await unlink(path2.join(rootDir, filePath));
+    }
+  }
+}
+async function collectLocalFiles(rootDir) {
+  const result = {};
+  await walkDir(rootDir, rootDir, result);
+  return result;
+}
+async function walkDir(rootDir, currentDir, result) {
+  const entries = await readdir(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (LOCAL_IGNORE_DIRS.has(entry.name)) continue;
+      await walkDir(rootDir, path2.join(currentDir, entry.name), result);
+    } else if (entry.isFile()) {
+      const filePath = path2.join(currentDir, entry.name);
+      const relativePath = path2.relative(rootDir, filePath);
+      result[relativePath] = await readTextFile(filePath);
+    }
+  }
+}
+async function writeManifest(rootDir, manifest) {
+  const filePath = path2.join(rootDir, MANIFEST_FILE);
+  await writeTextFile(filePath, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+async function writeRule(rootDir, ruleText) {
+  const filePath = path2.join(rootDir, RULE_FILE);
+  await writeTextFile(filePath, ruleText);
+}
+async function loadManifest(rootDir) {
+  const filePath = path2.join(rootDir, MANIFEST_FILE);
+  return readJsonFile(filePath);
+}
+async function loadRule(rootDir) {
+  const filePath = path2.join(rootDir, RULE_FILE);
+  return readTextFile(filePath);
+}
+async function writeSnapshot(rootDir) {
+  const files = await collectLocalFiles(rootDir);
+  await writeSnapshotFromFiles(rootDir, files);
+}
+async function writeSnapshotFromFiles(rootDir, files) {
+  const snapshot = {
+    files: {}
+  };
+  for (const [filePath, content] of Object.entries(files)) {
+    if (filePath.startsWith(`${PROJECT_DIR_NAME}/`)) continue;
+    snapshot.files[filePath] = hashContent(content);
+  }
+  const snapshotPath = path2.join(rootDir, PROJECT_DIR_NAME, SNAPSHOT_FILE);
+  await writeJsonFile(snapshotPath, snapshot);
+}
+async function getLocalDiff(rootDir) {
+  const snapshotPath = path2.join(rootDir, PROJECT_DIR_NAME, SNAPSHOT_FILE);
+  const snapshot = await readJsonFile(snapshotPath).catch(() => null);
+  if (!snapshot) {
+    return { modified: [], added: [], deleted: [] };
+  }
+  const files = await collectLocalFiles(rootDir);
+  const currentHashes = {};
+  for (const [filePath, content] of Object.entries(files)) {
+    if (filePath.startsWith(`${PROJECT_DIR_NAME}/`)) continue;
+    currentHashes[filePath] = hashContent(content);
+  }
+  const modified = [];
+  const added = [];
+  const deleted = [];
+  for (const [filePath, hash] of Object.entries(currentHashes)) {
+    const prevHash = snapshot.files[filePath];
+    if (!prevHash) {
+      added.push(filePath);
+    } else if (prevHash !== hash) {
+      modified.push(filePath);
+    }
+  }
+  for (const filePath of Object.keys(snapshot.files)) {
+    if (!currentHashes[filePath]) {
+      deleted.push(filePath);
+    }
+  }
+  return { modified, added, deleted };
+}
+
+export {
+  consola,
+  client,
+  DEFAULT_API_BASE_URL,
+  DEFAULT_WEB_BASE_URL,
+  CODE_EDITS_BUCKET,
+  PROJECT_DIR_NAME,
+  ENVIRONMENT_CONFIGS,
+  PROJECT_CONFIG_FILE,
+  MANIFEST_FILE,
+  RULE_FILE,
+  DEFAULT_LOGIN_TIMEOUT_MS,
+  DEFAULT_TURN_DELAY_MS,
+  ensureDir,
+  installSkillFile,
+  exists,
+  readTextFile,
+  readTextFileIfExists,
+  writeTextFile,
+  readJsonFile,
+  writeJsonFile,
+  hashContent,
+  getUserIdFromToken,
+  isAllowedGamePath,
+  isDynamicGeneratedPath,
+  isDynamicSeedPath,
+  isLibraryPath,
+  PRESERVED_USER_FILES,
+  isAllowedGamePath2,
+  isLibraryPath2,
+  writeSourceFiles,
+  writeScaffoldFiles,
+  removeExtraneousFiles,
+  collectLocalFiles,
+  writeManifest,
+  writeRule,
+  loadManifest,
+  loadRule,
+  writeSnapshot,
+  writeSnapshotFromFiles,
+  getLocalDiff
+};
+//# sourceMappingURL=chunk-FK6CWXQR.js.map