balladeer 1.0.6 → 1.0.8

package/dist/guidance-hook.mjs

@@ -0,0 +1,3114 @@
+import { createRequire as guidanceCreateRequire } from "node:module"; const require = guidanceCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/parser.js
+var require_parser = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/parser.js"(exports2, module2) {
+    "use strict";
+    var ParserEND = 1114112;
+    var ParserError = class _ParserError extends Error {
+      /* istanbul ignore next */
+      constructor(msg, filename, linenumber) {
+        super("[ParserError] " + msg, filename, linenumber);
+        this.name = "ParserError";
+        this.code = "ParserError";
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _ParserError);
+      }
+    };
+    var State = class {
+      constructor(parser) {
+        this.parser = parser;
+        this.buf = "";
+        this.returned = null;
+        this.result = null;
+        this.resultTable = null;
+        this.resultArr = null;
+      }
+    };
+    var Parser = class {
+      constructor() {
+        this.pos = 0;
+        this.col = 0;
+        this.line = 0;
+        this.obj = {};
+        this.ctx = this.obj;
+        this.stack = [];
+        this._buf = "";
+        this.char = null;
+        this.ii = 0;
+        this.state = new State(this.parseStart);
+      }
+      parse(str) {
+        if (str.length === 0 || str.length == null) return;
+        this._buf = String(str);
+        this.ii = -1;
+        this.char = -1;
+        let getNext;
+        while (getNext === false || this.nextChar()) {
+          getNext = this.runOne();
+        }
+        this._buf = null;
+      }
+      nextChar() {
+        if (this.char === 10) {
+          ++this.line;
+          this.col = -1;
+        }
+        ++this.ii;
+        this.char = this._buf.codePointAt(this.ii);
+        ++this.pos;
+        ++this.col;
+        return this.haveBuffer();
+      }
+      haveBuffer() {
+        return this.ii < this._buf.length;
+      }
+      runOne() {
+        return this.state.parser.call(this, this.state.returned);
+      }
+      finish() {
+        this.char = ParserEND;
+        let last;
+        do {
+          last = this.state.parser;
+          this.runOne();
+        } while (this.state.parser !== last);
+        this.ctx = null;
+        this.state = null;
+        this._buf = null;
+        return this.obj;
+      }
+      next(fn) {
+        if (typeof fn !== "function") throw new ParserError("Tried to set state to non-existent state: " + JSON.stringify(fn));
+        this.state.parser = fn;
+      }
+      goto(fn) {
+        this.next(fn);
+        return this.runOne();
+      }
+      call(fn, returnWith) {
+        if (returnWith) this.next(returnWith);
+        this.stack.push(this.state);
+        this.state = new State(fn);
+      }
+      callNow(fn, returnWith) {
+        this.call(fn, returnWith);
+        return this.runOne();
+      }
+      return(value) {
+        if (this.stack.length === 0) throw this.error(new ParserError("Stack underflow"));
+        if (value === void 0) value = this.state.buf;
+        this.state = this.stack.pop();
+        this.state.returned = value;
+      }
+      returnNow(value) {
+        this.return(value);
+        return this.runOne();
+      }
+      consume() {
+        if (this.char === ParserEND) throw this.error(new ParserError("Unexpected end-of-buffer"));
+        this.state.buf += this._buf[this.ii];
+      }
+      error(err) {
+        err.line = this.line;
+        err.col = this.col;
+        err.pos = this.pos;
+        return err;
+      }
+      /* istanbul ignore next */
+      parseStart() {
+        throw new ParserError("Must declare a parseStart method");
+      }
+    };
+    Parser.END = ParserEND;
+    Parser.Error = ParserError;
+    module2.exports = Parser;
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime.js
+var require_create_datetime = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (value) => {
+      const date = new Date(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/format-num.js
+var require_format_num = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/format-num.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (d, num) => {
+      num = String(num);
+      while (num.length < d) num = "0" + num;
+      return num;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime-float.js
+var require_create_datetime_float = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-datetime-float.js"(exports2, module2) {
+    "use strict";
+    var f = require_format_num();
+    var FloatingDateTime = class extends Date {
+      constructor(value) {
+        super(value + "Z");
+        this.isFloating = true;
+      }
+      toISOString() {
+        const date = `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+        const time = `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+        return `${date}T${time}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new FloatingDateTime(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-date.js
+var require_create_date = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-date.js"(exports2, module2) {
+    "use strict";
+    var f = require_format_num();
+    var DateTime = global.Date;
+    var Date2 = class extends DateTime {
+      constructor(value) {
+        super(value);
+        this.isDate = true;
+      }
+      toISOString() {
+        return `${this.getUTCFullYear()}-${f(2, this.getUTCMonth() + 1)}-${f(2, this.getUTCDate())}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new Date2(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-time.js
+var require_create_time = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/create-time.js"(exports2, module2) {
+    "use strict";
+    var f = require_format_num();
+    var Time = class extends Date {
+      constructor(value) {
+        super(`0000-01-01T${value}Z`);
+        this.isTime = true;
+      }
+      toISOString() {
+        return `${f(2, this.getUTCHours())}:${f(2, this.getUTCMinutes())}:${f(2, this.getUTCSeconds())}.${f(3, this.getUTCMilliseconds())}`;
+      }
+    };
+    module2.exports = (value) => {
+      const date = new Time(value);
+      if (isNaN(date)) {
+        throw new TypeError("Invalid Datetime");
+      } else {
+        return date;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/toml-parser.js
+var require_toml_parser = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/lib/toml-parser.js"(exports, module) {
+    "use strict";
+    module.exports = makeParserClass(require_parser());
+    module.exports.makeParserClass = makeParserClass;
+    var TomlError = class _TomlError extends Error {
+      constructor(msg) {
+        super(msg);
+        this.name = "TomlError";
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _TomlError);
+        this.fromTOML = true;
+        this.wrapped = null;
+      }
+    };
+    TomlError.wrap = (err) => {
+      const terr = new TomlError(err.message);
+      terr.code = err.code;
+      terr.wrapped = err;
+      return terr;
+    };
+    module.exports.TomlError = TomlError;
+    var createDateTime = require_create_datetime();
+    var createDateTimeFloat = require_create_datetime_float();
+    var createDate = require_create_date();
+    var createTime = require_create_time();
+    var CTRL_I = 9;
+    var CTRL_J = 10;
+    var CTRL_M = 13;
+    var CTRL_CHAR_BOUNDARY = 31;
+    var CHAR_SP = 32;
+    var CHAR_QUOT = 34;
+    var CHAR_NUM = 35;
+    var CHAR_APOS = 39;
+    var CHAR_PLUS = 43;
+    var CHAR_COMMA = 44;
+    var CHAR_HYPHEN = 45;
+    var CHAR_PERIOD = 46;
+    var CHAR_0 = 48;
+    var CHAR_1 = 49;
+    var CHAR_7 = 55;
+    var CHAR_9 = 57;
+    var CHAR_COLON = 58;
+    var CHAR_EQUALS = 61;
+    var CHAR_A = 65;
+    var CHAR_E = 69;
+    var CHAR_F = 70;
+    var CHAR_T = 84;
+    var CHAR_U = 85;
+    var CHAR_Z = 90;
+    var CHAR_LOWBAR = 95;
+    var CHAR_a = 97;
+    var CHAR_b = 98;
+    var CHAR_e = 101;
+    var CHAR_f = 102;
+    var CHAR_i = 105;
+    var CHAR_l = 108;
+    var CHAR_n = 110;
+    var CHAR_o = 111;
+    var CHAR_r = 114;
+    var CHAR_s = 115;
+    var CHAR_t = 116;
+    var CHAR_u = 117;
+    var CHAR_x = 120;
+    var CHAR_z = 122;
+    var CHAR_LCUB = 123;
+    var CHAR_RCUB = 125;
+    var CHAR_LSQB = 91;
+    var CHAR_BSOL = 92;
+    var CHAR_RSQB = 93;
+    var CHAR_DEL = 127;
+    var SURROGATE_FIRST = 55296;
+    var SURROGATE_LAST = 57343;
+    var escapes = {
+      [CHAR_b]: "\b",
+      [CHAR_t]: "	",
+      [CHAR_n]: "\n",
+      [CHAR_f]: "\f",
+      [CHAR_r]: "\r",
+      [CHAR_QUOT]: '"',
+      [CHAR_BSOL]: "\\"
+    };
+    function isDigit(cp) {
+      return cp >= CHAR_0 && cp <= CHAR_9;
+    }
+    function isHexit(cp) {
+      return cp >= CHAR_A && cp <= CHAR_F || cp >= CHAR_a && cp <= CHAR_f || cp >= CHAR_0 && cp <= CHAR_9;
+    }
+    function isBit(cp) {
+      return cp === CHAR_1 || cp === CHAR_0;
+    }
+    function isOctit(cp) {
+      return cp >= CHAR_0 && cp <= CHAR_7;
+    }
+    function isAlphaNumQuoteHyphen(cp) {
+      return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_APOS || cp === CHAR_QUOT || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+    }
+    function isAlphaNumHyphen(cp) {
+      return cp >= CHAR_A && cp <= CHAR_Z || cp >= CHAR_a && cp <= CHAR_z || cp >= CHAR_0 && cp <= CHAR_9 || cp === CHAR_LOWBAR || cp === CHAR_HYPHEN;
+    }
+    var _type = Symbol("type");
+    var _declared = Symbol("declared");
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var defineProperty = Object.defineProperty;
+    var descriptor = { configurable: true, enumerable: true, writable: true, value: void 0 };
+    function hasKey(obj, key) {
+      if (hasOwnProperty.call(obj, key)) return true;
+      if (key === "__proto__") defineProperty(obj, "__proto__", descriptor);
+      return false;
+    }
+    var INLINE_TABLE = Symbol("inline-table");
+    function InlineTable() {
+      return Object.defineProperties({}, {
+        [_type]: { value: INLINE_TABLE }
+      });
+    }
+    function isInlineTable(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INLINE_TABLE;
+    }
+    var TABLE = Symbol("table");
+    function Table() {
+      return Object.defineProperties({}, {
+        [_type]: { value: TABLE },
+        [_declared]: { value: false, writable: true }
+      });
+    }
+    function isTable(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === TABLE;
+    }
+    var _contentType = Symbol("content-type");
+    var INLINE_LIST = Symbol("inline-list");
+    function InlineList(type) {
+      return Object.defineProperties([], {
+        [_type]: { value: INLINE_LIST },
+        [_contentType]: { value: type }
+      });
+    }
+    function isInlineList(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INLINE_LIST;
+    }
+    var LIST = Symbol("list");
+    function List() {
+      return Object.defineProperties([], {
+        [_type]: { value: LIST }
+      });
+    }
+    function isList(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === LIST;
+    }
+    var _custom;
+    try {
+      const utilInspect = eval("require('util').inspect");
+      _custom = utilInspect.custom;
+    } catch (_) {
+    }
+    var _inspect = _custom || "inspect";
+    var BoxedBigInt = class {
+      constructor(value) {
+        try {
+          this.value = global.BigInt.asIntN(64, value);
+        } catch (_) {
+          this.value = null;
+        }
+        Object.defineProperty(this, _type, { value: INTEGER });
+      }
+      isNaN() {
+        return this.value === null;
+      }
+      /* istanbul ignore next */
+      toString() {
+        return String(this.value);
+      }
+      /* istanbul ignore next */
+      [_inspect]() {
+        return `[BigInt: ${this.toString()}]}`;
+      }
+      valueOf() {
+        return this.value;
+      }
+    };
+    var INTEGER = Symbol("integer");
+    function Integer(value) {
+      let num = Number(value);
+      if (Object.is(num, -0)) num = 0;
+      if (global.BigInt && !Number.isSafeInteger(num)) {
+        return new BoxedBigInt(value);
+      } else {
+        return Object.defineProperties(new Number(num), {
+          isNaN: { value: function() {
+            return isNaN(this);
+          } },
+          [_type]: { value: INTEGER },
+          [_inspect]: { value: () => `[Integer: ${value}]` }
+        });
+      }
+    }
+    function isInteger(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === INTEGER;
+    }
+    var FLOAT = Symbol("float");
+    function Float(value) {
+      return Object.defineProperties(new Number(value), {
+        [_type]: { value: FLOAT },
+        [_inspect]: { value: () => `[Float: ${value}]` }
+      });
+    }
+    function isFloat(obj) {
+      if (obj === null || typeof obj !== "object") return false;
+      return obj[_type] === FLOAT;
+    }
+    function tomlType(value) {
+      const type = typeof value;
+      if (type === "object") {
+        if (value === null) return "null";
+        if (value instanceof Date) return "datetime";
+        if (_type in value) {
+          switch (value[_type]) {
+            case INLINE_TABLE:
+              return "inline-table";
+            case INLINE_LIST:
+              return "inline-list";
+            /* istanbul ignore next */
+            case TABLE:
+              return "table";
+            /* istanbul ignore next */
+            case LIST:
+              return "list";
+            case FLOAT:
+              return "float";
+            case INTEGER:
+              return "integer";
+          }
+        }
+      }
+      return type;
+    }
+    function makeParserClass(Parser) {
+      class TOMLParser extends Parser {
+        constructor() {
+          super();
+          this.ctx = this.obj = Table();
+        }
+        /* MATCH HELPER */
+        atEndOfWord() {
+          return this.char === CHAR_NUM || this.char === CTRL_I || this.char === CHAR_SP || this.atEndOfLine();
+        }
+        atEndOfLine() {
+          return this.char === Parser.END || this.char === CTRL_J || this.char === CTRL_M;
+        }
+        parseStart() {
+          if (this.char === Parser.END) {
+            return null;
+          } else if (this.char === CHAR_LSQB) {
+            return this.call(this.parseTableOrList);
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else if (isAlphaNumQuoteHyphen(this.char)) {
+            return this.callNow(this.parseAssignStatement);
+          } else {
+            throw this.error(new TomlError(`Unknown character "${this.char}"`));
+          }
+        }
+        // HELPER, this strips any whitespace and comments to the end of the line
+        // then RETURNS. Last state in a production.
+        parseWhitespaceToEOL() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CHAR_NUM) {
+            return this.goto(this.parseComment);
+          } else if (this.char === Parser.END || this.char === CTRL_J) {
+            return this.return();
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected only whitespace or comments till end of line"));
+          }
+        }
+        /* ASSIGNMENT: key = value */
+        parseAssignStatement() {
+          return this.callNow(this.parseAssign, this.recordAssignStatement);
+        }
+        recordAssignStatement(kv) {
+          let target = this.ctx;
+          let finalKey = kv.key.pop();
+          for (let kw of kv.key) {
+            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            target = target[kw] = target[kw] || Table();
+          }
+          if (hasKey(target, finalKey)) {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          }
+          if (isInteger(kv.value) || isFloat(kv.value)) {
+            target[finalKey] = kv.value.valueOf();
+          } else {
+            target[finalKey] = kv.value;
+          }
+          return this.goto(this.parseWhitespaceToEOL);
+        }
+        /* ASSSIGNMENT expression, key = value possibly inside an inline table */
+        parseAssign() {
+          return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+        }
+        recordAssignKeyword(key) {
+          if (this.state.resultTable) {
+            this.state.resultTable.push(key);
+          } else {
+            this.state.resultTable = [key];
+          }
+          return this.goto(this.parseAssignKeywordPreDot);
+        }
+        parseAssignKeywordPreDot() {
+          if (this.char === CHAR_PERIOD) {
+            return this.next(this.parseAssignKeywordPostDot);
+          } else if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+            return this.goto(this.parseAssignEqual);
+          }
+        }
+        parseAssignKeywordPostDot() {
+          if (this.char !== CHAR_SP && this.char !== CTRL_I) {
+            return this.callNow(this.parseKeyword, this.recordAssignKeyword);
+          }
+        }
+        parseAssignEqual() {
+          if (this.char === CHAR_EQUALS) {
+            return this.next(this.parseAssignPreValue);
+          } else {
+            throw this.error(new TomlError('Invalid character, expected "="'));
+          }
+        }
+        parseAssignPreValue() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseValue, this.recordAssignValue);
+          }
+        }
+        recordAssignValue(value) {
+          return this.returnNow({ key: this.state.resultTable, value });
+        }
+        /* COMMENTS: #...eol */
+        parseComment() {
+          do {
+            if (this.char === Parser.END || this.char === CTRL_J) {
+              return this.return();
+            }
+          } while (this.nextChar());
+        }
+        /* TABLES AND LISTS, [foo] and [[foo]] */
+        parseTableOrList() {
+          if (this.char === CHAR_LSQB) {
+            this.next(this.parseList);
+          } else {
+            return this.goto(this.parseTable);
+          }
+        }
+        /* TABLE [foo.bar.baz] */
+        parseTable() {
+          this.ctx = this.obj;
+          return this.goto(this.parseTableNext);
+        }
+        parseTableNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseKeyword, this.parseTableMore);
+          }
+        }
+        parseTableMore(keyword) {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CHAR_RSQB) {
+            if (hasKey(this.ctx, keyword) && (!isTable(this.ctx[keyword]) || this.ctx[keyword][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            } else {
+              this.ctx = this.ctx[keyword] = this.ctx[keyword] || Table();
+              this.ctx[_declared] = true;
+            }
+            return this.next(this.parseWhitespaceToEOL);
+          } else if (this.char === CHAR_PERIOD) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx = this.ctx[keyword] = Table();
+            } else if (isTable(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword];
+            } else if (isList(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+            } else {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            return this.next(this.parseTableNext);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        /* LIST [[a.b.c]] */
+        parseList() {
+          this.ctx = this.obj;
+          return this.goto(this.parseListNext);
+        }
+        parseListNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else {
+            return this.callNow(this.parseKeyword, this.parseListMore);
+          }
+        }
+        parseListMore(keyword) {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CHAR_RSQB) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx[keyword] = List();
+            }
+            if (isInlineList(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline array"));
+            } else if (isList(this.ctx[keyword])) {
+              const next = Table();
+              this.ctx[keyword].push(next);
+              this.ctx = next;
+            } else {
+              throw this.error(new TomlError("Can't redefine an existing key"));
+            }
+            return this.next(this.parseListEnd);
+          } else if (this.char === CHAR_PERIOD) {
+            if (!hasKey(this.ctx, keyword)) {
+              this.ctx = this.ctx[keyword] = Table();
+            } else if (isInlineList(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline array"));
+            } else if (isInlineTable(this.ctx[keyword])) {
+              throw this.error(new TomlError("Can't extend an inline table"));
+            } else if (isList(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword][this.ctx[keyword].length - 1];
+            } else if (isTable(this.ctx[keyword])) {
+              this.ctx = this.ctx[keyword];
+            } else {
+              throw this.error(new TomlError("Can't redefine an existing key"));
+            }
+            return this.next(this.parseListNext);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        parseListEnd(keyword) {
+          if (this.char === CHAR_RSQB) {
+            return this.next(this.parseWhitespaceToEOL);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected whitespace, . or ]"));
+          }
+        }
+        /* VALUE string, number, boolean, inline list, inline object */
+        parseValue() {
+          if (this.char === Parser.END) {
+            throw this.error(new TomlError("Key without value"));
+          } else if (this.char === CHAR_QUOT) {
+            return this.next(this.parseDoubleString);
+          }
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseSingleString);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            return this.goto(this.parseNumberSign);
+          } else if (this.char === CHAR_i) {
+            return this.next(this.parseInf);
+          } else if (this.char === CHAR_n) {
+            return this.next(this.parseNan);
+          } else if (isDigit(this.char)) {
+            return this.goto(this.parseNumberOrDateTime);
+          } else if (this.char === CHAR_t || this.char === CHAR_f) {
+            return this.goto(this.parseBoolean);
+          } else if (this.char === CHAR_LSQB) {
+            return this.call(this.parseInlineList, this.recordValue);
+          } else if (this.char === CHAR_LCUB) {
+            return this.call(this.parseInlineTable, this.recordValue);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expecting string, number, datetime, boolean, inline array or inline table"));
+          }
+        }
+        recordValue(value) {
+          return this.returnNow(value);
+        }
+        parseInf() {
+          if (this.char === CHAR_n) {
+            return this.next(this.parseInf2);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+          }
+        }
+        parseInf2() {
+          if (this.char === CHAR_f) {
+            if (this.state.buf === "-") {
+              return this.return(-Infinity);
+            } else {
+              return this.return(Infinity);
+            }
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "inf", "+inf" or "-inf"'));
+          }
+        }
+        parseNan() {
+          if (this.char === CHAR_a) {
+            return this.next(this.parseNan2);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "nan"'));
+          }
+        }
+        parseNan2() {
+          if (this.char === CHAR_n) {
+            return this.return(NaN);
+          } else {
+            throw this.error(new TomlError('Unexpected character, expected "nan"'));
+          }
+        }
+        /* KEYS, barewords or basic, literal, or dotted */
+        parseKeyword() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseBasicString);
+          } else if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralString);
+          } else {
+            return this.goto(this.parseBareKey);
+          }
+        }
+        /* KEYS: barewords */
+        parseBareKey() {
+          do {
+            if (this.char === Parser.END) {
+              throw this.error(new TomlError("Key ended without value"));
+            } else if (isAlphaNumHyphen(this.char)) {
+              this.consume();
+            } else if (this.state.buf.length === 0) {
+              throw this.error(new TomlError("Empty bare keys are not allowed"));
+            } else {
+              return this.returnNow();
+            }
+          } while (this.nextChar());
+        }
+        /* STRINGS, single quoted (literal) */
+        parseSingleString() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiStringMaybe);
+          } else {
+            return this.goto(this.parseLiteralString);
+          }
+        }
+        parseLiteralString() {
+          do {
+            if (this.char === CHAR_APOS) {
+              return this.return();
+            } else if (this.atEndOfLine()) {
+              throw this.error(new TomlError("Unterminated string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        parseLiteralMultiStringMaybe() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiString);
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseLiteralMultiString() {
+          if (this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CTRL_J) {
+            return this.next(this.parseLiteralMultiStringContent);
+          } else {
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        parseLiteralMultiStringContent() {
+          do {
+            if (this.char === CHAR_APOS) {
+              return this.next(this.parseLiteralMultiEnd);
+            } else if (this.char === Parser.END) {
+              throw this.error(new TomlError("Unterminated multi-line string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        parseLiteralMultiEnd() {
+          if (this.char === CHAR_APOS) {
+            return this.next(this.parseLiteralMultiEnd2);
+          } else {
+            this.state.buf += "'";
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        parseLiteralMultiEnd2() {
+          if (this.char === CHAR_APOS) {
+            return this.return();
+          } else {
+            this.state.buf += "''";
+            return this.goto(this.parseLiteralMultiStringContent);
+          }
+        }
+        /* STRINGS double quoted */
+        parseDoubleString() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiStringMaybe);
+          } else {
+            return this.goto(this.parseBasicString);
+          }
+        }
+        parseBasicString() {
+          do {
+            if (this.char === CHAR_BSOL) {
+              return this.call(this.parseEscape, this.recordEscapeReplacement);
+            } else if (this.char === CHAR_QUOT) {
+              return this.return();
+            } else if (this.atEndOfLine()) {
+              throw this.error(new TomlError("Unterminated string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        recordEscapeReplacement(replacement) {
+          this.state.buf += replacement;
+          return this.goto(this.parseBasicString);
+        }
+        parseMultiStringMaybe() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiString);
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseMultiString() {
+          if (this.char === CTRL_M) {
+            return null;
+          } else if (this.char === CTRL_J) {
+            return this.next(this.parseMultiStringContent);
+          } else {
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiStringContent() {
+          do {
+            if (this.char === CHAR_BSOL) {
+              return this.call(this.parseMultiEscape, this.recordMultiEscapeReplacement);
+            } else if (this.char === CHAR_QUOT) {
+              return this.next(this.parseMultiEnd);
+            } else if (this.char === Parser.END) {
+              throw this.error(new TomlError("Unterminated multi-line string"));
+            } else if (this.char === CHAR_DEL || this.char <= CTRL_CHAR_BOUNDARY && this.char !== CTRL_I && this.char !== CTRL_J && this.char !== CTRL_M) {
+              throw this.errorControlCharInString();
+            } else {
+              this.consume();
+            }
+          } while (this.nextChar());
+        }
+        errorControlCharInString() {
+          let displayCode = "\\u00";
+          if (this.char < 16) {
+            displayCode += "0";
+          }
+          displayCode += this.char.toString(16);
+          return this.error(new TomlError(`Control characters (codes < 0x1f and 0x7f) are not allowed in strings, use ${displayCode} instead`));
+        }
+        recordMultiEscapeReplacement(replacement) {
+          this.state.buf += replacement;
+          return this.goto(this.parseMultiStringContent);
+        }
+        parseMultiEnd() {
+          if (this.char === CHAR_QUOT) {
+            return this.next(this.parseMultiEnd2);
+          } else {
+            this.state.buf += '"';
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiEnd2() {
+          if (this.char === CHAR_QUOT) {
+            return this.return();
+          } else {
+            this.state.buf += '""';
+            return this.goto(this.parseMultiStringContent);
+          }
+        }
+        parseMultiEscape() {
+          if (this.char === CTRL_M || this.char === CTRL_J) {
+            return this.next(this.parseMultiTrim);
+          } else if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return this.next(this.parsePreMultiTrim);
+          } else {
+            return this.goto(this.parseEscape);
+          }
+        }
+        parsePreMultiTrim() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === CTRL_M || this.char === CTRL_J) {
+            return this.next(this.parseMultiTrim);
+          } else {
+            throw this.error(new TomlError("Can't escape whitespace"));
+          }
+        }
+        parseMultiTrim() {
+          if (this.char === CTRL_J || this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M) {
+            return null;
+          } else {
+            return this.returnNow();
+          }
+        }
+        parseEscape() {
+          if (this.char in escapes) {
+            return this.return(escapes[this.char]);
+          } else if (this.char === CHAR_u) {
+            return this.call(this.parseSmallUnicode, this.parseUnicodeReturn);
+          } else if (this.char === CHAR_U) {
+            return this.call(this.parseLargeUnicode, this.parseUnicodeReturn);
+          } else {
+            throw this.error(new TomlError("Unknown escape character: " + this.char));
+          }
+        }
+        parseUnicodeReturn(char) {
+          try {
+            const codePoint = parseInt(char, 16);
+            if (codePoint >= SURROGATE_FIRST && codePoint <= SURROGATE_LAST) {
+              throw this.error(new TomlError("Invalid unicode, character in range 0xD800 - 0xDFFF is reserved"));
+            }
+            return this.returnNow(String.fromCodePoint(codePoint));
+          } catch (err) {
+            throw this.error(TomlError.wrap(err));
+          }
+        }
+        parseSmallUnicode() {
+          if (!isHexit(this.char)) {
+            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+          } else {
+            this.consume();
+            if (this.state.buf.length >= 4) return this.return();
+          }
+        }
+        parseLargeUnicode() {
+          if (!isHexit(this.char)) {
+            throw this.error(new TomlError("Invalid character in unicode sequence, expected hex"));
+          } else {
+            this.consume();
+            if (this.state.buf.length >= 8) return this.return();
+          }
+        }
+        /* NUMBERS */
+        parseNumberSign() {
+          this.consume();
+          return this.next(this.parseMaybeSignedInfOrNan);
+        }
+        parseMaybeSignedInfOrNan() {
+          if (this.char === CHAR_i) {
+            return this.next(this.parseInf);
+          } else if (this.char === CHAR_n) {
+            return this.next(this.parseNan);
+          } else {
+            return this.callNow(this.parseNoUnder, this.parseNumberIntegerStart);
+          }
+        }
+        parseNumberIntegerStart() {
+          if (this.char === CHAR_0) {
+            this.consume();
+            return this.next(this.parseNumberIntegerExponentOrDecimal);
+          } else {
+            return this.goto(this.parseNumberInteger);
+          }
+        }
+        parseNumberIntegerExponentOrDecimal() {
+          if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseNumberInteger() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseNoUnder() {
+          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD || this.char === CHAR_E || this.char === CHAR_e) {
+            throw this.error(new TomlError("Unexpected character, expected digit"));
+          } else if (this.atEndOfWord()) {
+            throw this.error(new TomlError("Incomplete number"));
+          }
+          return this.returnNow();
+        }
+        parseNoUnderHexOctBinLiteral() {
+          if (this.char === CHAR_LOWBAR || this.char === CHAR_PERIOD) {
+            throw this.error(new TomlError("Unexpected character, expected digit"));
+          } else if (this.atEndOfWord()) {
+            throw this.error(new TomlError("Incomplete number"));
+          }
+          return this.returnNow();
+        }
+        parseNumberFloat() {
+          if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else {
+            return this.returnNow(Float(this.state.buf));
+          }
+        }
+        parseNumberExponentSign() {
+          if (isDigit(this.char)) {
+            return this.goto(this.parseNumberExponent);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.call(this.parseNoUnder, this.parseNumberExponent);
+          } else {
+            throw this.error(new TomlError("Unexpected character, expected -, + or digit"));
+          }
+        }
+        parseNumberExponent() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder);
+          } else {
+            return this.returnNow(Float(this.state.buf));
+          }
+        }
+        /* NUMBERS or DATETIMES  */
+        parseNumberOrDateTime() {
+          if (this.char === CHAR_0) {
+            this.consume();
+            return this.next(this.parseNumberBaseOrDateTime);
+          } else {
+            return this.goto(this.parseNumberOrDateTimeOnly);
+          }
+        }
+        parseNumberOrDateTimeOnly() {
+          if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnder, this.parseNumberInteger);
+          } else if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length > 4) this.next(this.parseNumberInteger);
+          } else if (this.char === CHAR_E || this.char === CHAR_e) {
+            this.consume();
+            return this.next(this.parseNumberExponentSign);
+          } else if (this.char === CHAR_PERIOD) {
+            this.consume();
+            return this.call(this.parseNoUnder, this.parseNumberFloat);
+          } else if (this.char === CHAR_HYPHEN) {
+            return this.goto(this.parseDateTime);
+          } else if (this.char === CHAR_COLON) {
+            return this.goto(this.parseOnlyTimeHour);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseDateTimeOnly() {
+          if (this.state.buf.length < 4) {
+            if (isDigit(this.char)) {
+              return this.consume();
+            } else if (this.char === CHAR_COLON) {
+              return this.goto(this.parseOnlyTimeHour);
+            } else {
+              throw this.error(new TomlError("Expected digit while parsing year part of a date"));
+            }
+          } else {
+            if (this.char === CHAR_HYPHEN) {
+              return this.goto(this.parseDateTime);
+            } else {
+              throw this.error(new TomlError("Expected hyphen (-) while parsing year part of date"));
+            }
+          }
+        }
+        parseNumberBaseOrDateTime() {
+          if (this.char === CHAR_b) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerBin);
+          } else if (this.char === CHAR_o) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerOct);
+          } else if (this.char === CHAR_x) {
+            this.consume();
+            return this.call(this.parseNoUnderHexOctBinLiteral, this.parseIntegerHex);
+          } else if (this.char === CHAR_PERIOD) {
+            return this.goto(this.parseNumberInteger);
+          } else if (isDigit(this.char)) {
+            return this.goto(this.parseDateTimeOnly);
+          } else {
+            return this.returnNow(Integer(this.state.buf));
+          }
+        }
+        parseIntegerHex() {
+          if (isHexit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseIntegerOct() {
+          if (isOctit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        parseIntegerBin() {
+          if (isBit(this.char)) {
+            this.consume();
+          } else if (this.char === CHAR_LOWBAR) {
+            return this.call(this.parseNoUnderHexOctBinLiteral);
+          } else {
+            const result = Integer(this.state.buf);
+            if (result.isNaN()) {
+              throw this.error(new TomlError("Invalid number"));
+            } else {
+              return this.returnNow(result);
+            }
+          }
+        }
+        /* DATETIME */
+        parseDateTime() {
+          if (this.state.buf.length < 4) {
+            throw this.error(new TomlError("Years less than 1000 must be zero padded to four characters"));
+          }
+          this.state.result = this.state.buf;
+          this.state.buf = "";
+          return this.next(this.parseDateMonth);
+        }
+        parseDateMonth() {
+          if (this.char === CHAR_HYPHEN) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Months less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "-" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseDateDay);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseDateDay() {
+          if (this.char === CHAR_T || this.char === CHAR_SP) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Days less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "-" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseStartTimeHour);
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDate(this.state.result + "-" + this.state.buf));
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseStartTimeHour() {
+          if (this.atEndOfWord()) {
+            return this.returnNow(createDate(this.state.result));
+          } else {
+            return this.goto(this.parseTimeHour);
+          }
+        }
+        parseTimeHour() {
+          if (this.char === CHAR_COLON) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+            }
+            this.state.result += "T" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseTimeMin);
+          } else if (isDigit(this.char)) {
+            this.consume();
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseTimeMin() {
+          if (this.state.buf.length < 2 && isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+            this.state.result += ":" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseTimeSec);
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseTimeSec() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length === 2) {
+              this.state.result += ":" + this.state.buf;
+              this.state.buf = "";
+              return this.next(this.parseTimeZoneOrFraction);
+            }
+          } else {
+            throw this.error(new TomlError("Incomplete datetime"));
+          }
+        }
+        parseOnlyTimeHour() {
+          if (this.char === CHAR_COLON) {
+            if (this.state.buf.length < 2) {
+              throw this.error(new TomlError("Hours less than 10 must be zero padded to two characters"));
+            }
+            this.state.result = this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseOnlyTimeMin);
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeMin() {
+          if (this.state.buf.length < 2 && isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 2 && this.char === CHAR_COLON) {
+            this.state.result += ":" + this.state.buf;
+            this.state.buf = "";
+            return this.next(this.parseOnlyTimeSec);
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeSec() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (this.state.buf.length === 2) {
+              return this.next(this.parseOnlyTimeFractionMaybe);
+            }
+          } else {
+            throw this.error(new TomlError("Incomplete time"));
+          }
+        }
+        parseOnlyTimeFractionMaybe() {
+          this.state.result += ":" + this.state.buf;
+          if (this.char === CHAR_PERIOD) {
+            this.state.buf = "";
+            this.next(this.parseOnlyTimeFraction);
+          } else {
+            return this.return(createTime(this.state.result));
+          }
+        }
+        parseOnlyTimeFraction() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.atEndOfWord()) {
+            if (this.state.buf.length === 0) throw this.error(new TomlError("Expected digit in milliseconds"));
+            return this.returnNow(createTime(this.state.result + "." + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseTimeZoneOrFraction() {
+          if (this.char === CHAR_PERIOD) {
+            this.consume();
+            this.next(this.parseDateTimeFraction);
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.next(this.parseTimeZoneHour);
+          } else if (this.char === CHAR_Z) {
+            this.consume();
+            return this.return(createDateTime(this.state.result + this.state.buf));
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseDateTimeFraction() {
+          if (isDigit(this.char)) {
+            this.consume();
+          } else if (this.state.buf.length === 1) {
+            throw this.error(new TomlError("Expected digit in milliseconds"));
+          } else if (this.char === CHAR_HYPHEN || this.char === CHAR_PLUS) {
+            this.consume();
+            this.next(this.parseTimeZoneHour);
+          } else if (this.char === CHAR_Z) {
+            this.consume();
+            return this.return(createDateTime(this.state.result + this.state.buf));
+          } else if (this.atEndOfWord()) {
+            return this.returnNow(createDateTimeFloat(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected period (.), minus (-), plus (+) or Z"));
+          }
+        }
+        parseTimeZoneHour() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (/\d\d$/.test(this.state.buf)) return this.next(this.parseTimeZoneSep);
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+          }
+        }
+        parseTimeZoneSep() {
+          if (this.char === CHAR_COLON) {
+            this.consume();
+            this.next(this.parseTimeZoneMin);
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected colon"));
+          }
+        }
+        parseTimeZoneMin() {
+          if (isDigit(this.char)) {
+            this.consume();
+            if (/\d\d$/.test(this.state.buf)) return this.return(createDateTime(this.state.result + this.state.buf));
+          } else {
+            throw this.error(new TomlError("Unexpected character in datetime, expected digit"));
+          }
+        }
+        /* BOOLEAN */
+        parseBoolean() {
+          if (this.char === CHAR_t) {
+            this.consume();
+            return this.next(this.parseTrue_r);
+          } else if (this.char === CHAR_f) {
+            this.consume();
+            return this.next(this.parseFalse_a);
+          }
+        }
+        parseTrue_r() {
+          if (this.char === CHAR_r) {
+            this.consume();
+            return this.next(this.parseTrue_u);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseTrue_u() {
+          if (this.char === CHAR_u) {
+            this.consume();
+            return this.next(this.parseTrue_e);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseTrue_e() {
+          if (this.char === CHAR_e) {
+            return this.return(true);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_a() {
+          if (this.char === CHAR_a) {
+            this.consume();
+            return this.next(this.parseFalse_l);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_l() {
+          if (this.char === CHAR_l) {
+            this.consume();
+            return this.next(this.parseFalse_s);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_s() {
+          if (this.char === CHAR_s) {
+            this.consume();
+            return this.next(this.parseFalse_e);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        parseFalse_e() {
+          if (this.char === CHAR_e) {
+            return this.return(false);
+          } else {
+            throw this.error(new TomlError("Invalid boolean, expected true or false"));
+          }
+        }
+        /* INLINE LISTS */
+        parseInlineList() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+            return null;
+          } else if (this.char === Parser.END) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CHAR_RSQB) {
+            return this.return(this.state.resultArr || InlineList());
+          } else {
+            return this.callNow(this.parseValue, this.recordInlineListValue);
+          }
+        }
+        recordInlineListValue(value) {
+          if (this.state.resultArr) {
+            const listType = this.state.resultArr[_contentType];
+            const valueType = tomlType(value);
+            if (listType !== valueType) {
+              throw this.error(new TomlError(`Inline lists must be a single type, not a mix of ${listType} and ${valueType}`));
+            }
+          } else {
+            this.state.resultArr = InlineList(tomlType(value));
+          }
+          if (isFloat(value) || isInteger(value)) {
+            this.state.resultArr.push(value.valueOf());
+          } else {
+            this.state.resultArr.push(value);
+          }
+          return this.goto(this.parseInlineListNext);
+        }
+        parseInlineListNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I || this.char === CTRL_M || this.char === CTRL_J) {
+            return null;
+          } else if (this.char === CHAR_NUM) {
+            return this.call(this.parseComment);
+          } else if (this.char === CHAR_COMMA) {
+            return this.next(this.parseInlineList);
+          } else if (this.char === CHAR_RSQB) {
+            return this.goto(this.parseInlineList);
+          } else {
+            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+          }
+        }
+        /* INLINE TABLE */
+        parseInlineTable() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_RCUB) {
+            return this.return(this.state.resultTable || InlineTable());
+          } else {
+            if (!this.state.resultTable) this.state.resultTable = InlineTable();
+            return this.callNow(this.parseAssign, this.recordInlineTableValue);
+          }
+        }
+        recordInlineTableValue(kv) {
+          let target = this.state.resultTable;
+          let finalKey = kv.key.pop();
+          for (let kw of kv.key) {
+            if (hasKey(target, kw) && (!isTable(target[kw]) || target[kw][_declared])) {
+              throw this.error(new TomlError("Can't redefine existing key"));
+            }
+            target = target[kw] = target[kw] || Table();
+          }
+          if (hasKey(target, finalKey)) {
+            throw this.error(new TomlError("Can't redefine existing key"));
+          }
+          if (isInteger(kv.value) || isFloat(kv.value)) {
+            target[finalKey] = kv.value.valueOf();
+          } else {
+            target[finalKey] = kv.value;
+          }
+          return this.goto(this.parseInlineTableNext);
+        }
+        parseInlineTableNext() {
+          if (this.char === CHAR_SP || this.char === CTRL_I) {
+            return null;
+          } else if (this.char === Parser.END || this.char === CHAR_NUM || this.char === CTRL_J || this.char === CTRL_M) {
+            throw this.error(new TomlError("Unterminated inline array"));
+          } else if (this.char === CHAR_COMMA) {
+            return this.next(this.parseInlineTable);
+          } else if (this.char === CHAR_RCUB) {
+            return this.goto(this.parseInlineTable);
+          } else {
+            throw this.error(new TomlError("Invalid character, expected whitespace, comma (,) or close bracket (])"));
+          }
+        }
+      }
+      return TOMLParser;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-pretty-error.js
+var require_parse_pretty_error = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-pretty-error.js"(exports2, module2) {
+    "use strict";
+    module2.exports = prettyError;
+    function prettyError(err, buf) {
+      if (err.pos == null || err.line == null) return err;
+      let msg = err.message;
+      msg += ` at row ${err.line + 1}, col ${err.col + 1}, pos ${err.pos}:
+`;
+      if (buf && buf.split) {
+        const lines = buf.split(/\n/);
+        const lineNumWidth = String(Math.min(lines.length, err.line + 3)).length;
+        let linePadding = " ";
+        while (linePadding.length < lineNumWidth) linePadding += " ";
+        for (let ii = Math.max(0, err.line - 1); ii < Math.min(lines.length, err.line + 2); ++ii) {
+          let lineNum = String(ii + 1);
+          if (lineNum.length < lineNumWidth) lineNum = " " + lineNum;
+          if (err.line === ii) {
+            msg += lineNum + "> " + lines[ii] + "\n";
+            msg += linePadding + "  ";
+            for (let hh = 0; hh < err.col; ++hh) {
+              msg += " ";
+            }
+            msg += "^\n";
+          } else {
+            msg += lineNum + ": " + lines[ii] + "\n";
+          }
+        }
+      }
+      err.message = msg + "\n";
+      return err;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-string.js
+var require_parse_string = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-string.js"(exports2, module2) {
+    "use strict";
+    module2.exports = parseString;
+    var TOMLParser = require_toml_parser();
+    var prettyError = require_parse_pretty_error();
+    function parseString(str) {
+      if (global.Buffer && global.Buffer.isBuffer(str)) {
+        str = str.toString("utf8");
+      }
+      const parser = new TOMLParser();
+      try {
+        parser.parse(str);
+        return parser.finish();
+      } catch (err) {
+        throw prettyError(err, str);
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-async.js
+var require_parse_async = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-async.js"(exports2, module2) {
+    "use strict";
+    module2.exports = parseAsync;
+    var TOMLParser = require_toml_parser();
+    var prettyError = require_parse_pretty_error();
+    function parseAsync(str, opts) {
+      if (!opts) opts = {};
+      const index = 0;
+      const blocksize = opts.blocksize || 40960;
+      const parser = new TOMLParser();
+      return new Promise((resolve2, reject) => {
+        setImmediate(parseAsyncNext, index, blocksize, resolve2, reject);
+      });
+      function parseAsyncNext(index2, blocksize2, resolve2, reject) {
+        if (index2 >= str.length) {
+          try {
+            return resolve2(parser.finish());
+          } catch (err) {
+            return reject(prettyError(err, str));
+          }
+        }
+        try {
+          parser.parse(str.slice(index2, index2 + blocksize2));
+          setImmediate(parseAsyncNext, index2 + blocksize2, blocksize2, resolve2, reject);
+        } catch (err) {
+          reject(prettyError(err, str));
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-stream.js
+var require_parse_stream = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse-stream.js"(exports2, module2) {
+    "use strict";
+    module2.exports = parseStream;
+    var stream = __require("stream");
+    var TOMLParser = require_toml_parser();
+    function parseStream(stm) {
+      if (stm) {
+        return parseReadable(stm);
+      } else {
+        return parseTransform(stm);
+      }
+    }
+    function parseReadable(stm) {
+      const parser = new TOMLParser();
+      stm.setEncoding("utf8");
+      return new Promise((resolve2, reject) => {
+        let readable;
+        let ended = false;
+        let errored = false;
+        function finish() {
+          ended = true;
+          if (readable) return;
+          try {
+            resolve2(parser.finish());
+          } catch (err) {
+            reject(err);
+          }
+        }
+        function error(err) {
+          errored = true;
+          reject(err);
+        }
+        stm.once("end", finish);
+        stm.once("error", error);
+        readNext();
+        function readNext() {
+          readable = true;
+          let data;
+          while ((data = stm.read()) !== null) {
+            try {
+              parser.parse(data);
+            } catch (err) {
+              return error(err);
+            }
+          }
+          readable = false;
+          if (ended) return finish();
+          if (errored) return;
+          stm.once("readable", readNext);
+        }
+      });
+    }
+    function parseTransform() {
+      const parser = new TOMLParser();
+      return new stream.Transform({
+        objectMode: true,
+        transform(chunk, encoding, cb) {
+          try {
+            parser.parse(chunk.toString(encoding));
+          } catch (err) {
+            this.emit("error", err);
+          }
+          cb();
+        },
+        flush(cb) {
+          try {
+            this.push(parser.finish());
+          } catch (err) {
+            this.emit("error", err);
+          }
+          cb();
+        }
+      });
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/parse.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_parse_string();
+    module2.exports.async = require_parse_async();
+    module2.exports.stream = require_parse_stream();
+    module2.exports.prettyError = require_parse_pretty_error();
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/stringify.js
+var require_stringify = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/stringify.js"(exports2, module2) {
+    "use strict";
+    module2.exports = stringify;
+    module2.exports.value = stringifyInline;
+    function stringify(obj) {
+      if (obj === null) throw typeError("null");
+      if (obj === void 0) throw typeError("undefined");
+      if (typeof obj !== "object") throw typeError(typeof obj);
+      if (typeof obj.toJSON === "function") obj = obj.toJSON();
+      if (obj == null) return null;
+      const type = tomlType2(obj);
+      if (type !== "table") throw typeError(type);
+      return stringifyObject("", "", obj);
+    }
+    function typeError(type) {
+      return new Error("Can only stringify objects, not " + type);
+    }
+    function arrayOneTypeError() {
+      return new Error("Array values can't have mixed types");
+    }
+    function getInlineKeys(obj) {
+      return Object.keys(obj).filter((key) => isInline(obj[key]));
+    }
+    function getComplexKeys(obj) {
+      return Object.keys(obj).filter((key) => !isInline(obj[key]));
+    }
+    function toJSON(obj) {
+      let nobj = Array.isArray(obj) ? [] : Object.prototype.hasOwnProperty.call(obj, "__proto__") ? { ["__proto__"]: void 0 } : {};
+      for (let prop of Object.keys(obj)) {
+        if (obj[prop] && typeof obj[prop].toJSON === "function" && !("toISOString" in obj[prop])) {
+          nobj[prop] = obj[prop].toJSON();
+        } else {
+          nobj[prop] = obj[prop];
+        }
+      }
+      return nobj;
+    }
+    function stringifyObject(prefix, indent, obj) {
+      obj = toJSON(obj);
+      var inlineKeys;
+      var complexKeys;
+      inlineKeys = getInlineKeys(obj);
+      complexKeys = getComplexKeys(obj);
+      var result = [];
+      var inlineIndent = indent || "";
+      inlineKeys.forEach((key) => {
+        var type = tomlType2(obj[key]);
+        if (type !== "undefined" && type !== "null") {
+          result.push(inlineIndent + stringifyKey(key) + " = " + stringifyAnyInline(obj[key], true));
+        }
+      });
+      if (result.length > 0) result.push("");
+      var complexIndent = prefix && inlineKeys.length > 0 ? indent + "  " : "";
+      complexKeys.forEach((key) => {
+        result.push(stringifyComplex(prefix, complexIndent, key, obj[key]));
+      });
+      return result.join("\n");
+    }
+    function isInline(value) {
+      switch (tomlType2(value)) {
+        case "undefined":
+        case "null":
+        case "integer":
+        case "nan":
+        case "float":
+        case "boolean":
+        case "string":
+        case "datetime":
+          return true;
+        case "array":
+          return value.length === 0 || tomlType2(value[0]) !== "table";
+        case "table":
+          return Object.keys(value).length === 0;
+        /* istanbul ignore next */
+        default:
+          return false;
+      }
+    }
+    function tomlType2(value) {
+      if (value === void 0) {
+        return "undefined";
+      } else if (value === null) {
+        return "null";
+      } else if (typeof value === "bigint" || Number.isInteger(value) && !Object.is(value, -0)) {
+        return "integer";
+      } else if (typeof value === "number") {
+        return "float";
+      } else if (typeof value === "boolean") {
+        return "boolean";
+      } else if (typeof value === "string") {
+        return "string";
+      } else if ("toISOString" in value) {
+        return isNaN(value) ? "undefined" : "datetime";
+      } else if (Array.isArray(value)) {
+        return "array";
+      } else {
+        return "table";
+      }
+    }
+    function stringifyKey(key) {
+      var keyStr = String(key);
+      if (/^[-A-Za-z0-9_]+$/.test(keyStr)) {
+        return keyStr;
+      } else {
+        return stringifyBasicString(keyStr);
+      }
+    }
+    function stringifyBasicString(str) {
+      return '"' + escapeString(str).replace(/"/g, '\\"') + '"';
+    }
+    function stringifyLiteralString(str) {
+      return "'" + str + "'";
+    }
+    function numpad(num, str) {
+      while (str.length < num) str = "0" + str;
+      return str;
+    }
+    function escapeString(str) {
+      return str.replace(/\\/g, "\\\\").replace(/[\b]/g, "\\b").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\f/g, "\\f").replace(/\r/g, "\\r").replace(/([\u0000-\u001f\u007f])/, (c) => "\\u" + numpad(4, c.codePointAt(0).toString(16)));
+    }
+    function stringifyMultilineString(str) {
+      let escaped = str.split(/\n/).map((str2) => {
+        return escapeString(str2).replace(/"(?="")/g, '\\"');
+      }).join("\n");
+      if (escaped.slice(-1) === '"') escaped += "\\\n";
+      return '"""\n' + escaped + '"""';
+    }
+    function stringifyAnyInline(value, multilineOk) {
+      let type = tomlType2(value);
+      if (type === "string") {
+        if (multilineOk && /\n/.test(value)) {
+          type = "string-multiline";
+        } else if (!/[\b\t\n\f\r']/.test(value) && /"/.test(value)) {
+          type = "string-literal";
+        }
+      }
+      return stringifyInline(value, type);
+    }
+    function stringifyInline(value, type) {
+      if (!type) type = tomlType2(value);
+      switch (type) {
+        case "string-multiline":
+          return stringifyMultilineString(value);
+        case "string":
+          return stringifyBasicString(value);
+        case "string-literal":
+          return stringifyLiteralString(value);
+        case "integer":
+          return stringifyInteger(value);
+        case "float":
+          return stringifyFloat(value);
+        case "boolean":
+          return stringifyBoolean(value);
+        case "datetime":
+          return stringifyDatetime(value);
+        case "array":
+          return stringifyInlineArray(value.filter((_) => tomlType2(_) !== "null" && tomlType2(_) !== "undefined" && tomlType2(_) !== "nan"));
+        case "table":
+          return stringifyInlineTable(value);
+        /* istanbul ignore next */
+        default:
+          throw typeError(type);
+      }
+    }
+    function stringifyInteger(value) {
+      return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, "_");
+    }
+    function stringifyFloat(value) {
+      if (value === Infinity) {
+        return "inf";
+      } else if (value === -Infinity) {
+        return "-inf";
+      } else if (Object.is(value, NaN)) {
+        return "nan";
+      } else if (Object.is(value, -0)) {
+        return "-0.0";
+      }
+      var chunks = String(value).split(".");
+      var int = chunks[0];
+      var dec = chunks[1] || 0;
+      return stringifyInteger(int) + "." + dec;
+    }
+    function stringifyBoolean(value) {
+      return String(value);
+    }
+    function stringifyDatetime(value) {
+      return value.toISOString();
+    }
+    function isNumber(type) {
+      return type === "float" || type === "integer";
+    }
+    function arrayType(values) {
+      var contentType = tomlType2(values[0]);
+      if (values.every((_) => tomlType2(_) === contentType)) return contentType;
+      if (values.every((_) => isNumber(tomlType2(_)))) return "float";
+      return "mixed";
+    }
+    function validateArray(values) {
+      const type = arrayType(values);
+      if (type === "mixed") {
+        throw arrayOneTypeError();
+      }
+      return type;
+    }
+    function stringifyInlineArray(values) {
+      values = toJSON(values);
+      const type = validateArray(values);
+      var result = "[";
+      var stringified = values.map((_) => stringifyInline(_, type));
+      if (stringified.join(", ").length > 60 || /\n/.test(stringified)) {
+        result += "\n  " + stringified.join(",\n  ") + "\n";
+      } else {
+        result += " " + stringified.join(", ") + (stringified.length > 0 ? " " : "");
+      }
+      return result + "]";
+    }
+    function stringifyInlineTable(value) {
+      value = toJSON(value);
+      var result = [];
+      Object.keys(value).forEach((key) => {
+        result.push(stringifyKey(key) + " = " + stringifyAnyInline(value[key], false));
+      });
+      return "{ " + result.join(", ") + (result.length > 0 ? " " : "") + "}";
+    }
+    function stringifyComplex(prefix, indent, key, value) {
+      var valueType = tomlType2(value);
+      if (valueType === "array") {
+        return stringifyArrayOfTables(prefix, indent, key, value);
+      } else if (valueType === "table") {
+        return stringifyComplexTable(prefix, indent, key, value);
+      } else {
+        throw typeError(valueType);
+      }
+    }
+    function stringifyArrayOfTables(prefix, indent, key, values) {
+      values = toJSON(values);
+      validateArray(values);
+      var firstValueType = tomlType2(values[0]);
+      if (firstValueType !== "table") throw typeError(firstValueType);
+      var fullKey = prefix + stringifyKey(key);
+      var result = "";
+      values.forEach((table) => {
+        if (result.length > 0) result += "\n";
+        result += indent + "[[" + fullKey + "]]\n";
+        result += stringifyObject(fullKey + ".", indent, table);
+      });
+      return result;
+    }
+    function stringifyComplexTable(prefix, indent, key, value) {
+      var fullKey = prefix + stringifyKey(key);
+      var result = "";
+      if (getInlineKeys(value).length > 0) {
+        result += indent + "[" + fullKey + "]\n";
+      }
+      return result + stringifyObject(fullKey + ".", indent, value);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/toml.js
+var require_toml = __commonJS({
+  "../../node_modules/.pnpm/@iarna+toml@2.2.5/node_modules/@iarna/toml/toml.js"(exports2) {
+    "use strict";
+    exports2.parse = require_parse();
+    exports2.stringify = require_stringify();
+  }
+});
+
+// src/wire.ts
+var CLI_VERSION = "1.0.8";
+var CLIENT_HEADER = "x-balladeer-client";
+var CLIENT_HEADER_VALUE = `balladeer/${CLI_VERSION}`;
+var DEFAULT_CONTROL_PLANE = "https://envelopes.balladeer.ai";
+
+// src/store.ts
+import {
+  closeSync,
+  fchmodSync,
+  fsyncSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, parse, resolve } from "node:path";
+var StoreError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "StoreError";
+    this.code = code;
+  }
+};
+var EMPTY = { version: 1, pendingPairings: [], sessions: [], agents: [] };
+function configHome(environment = process.env) {
+  const explicit = environment.BALLADEER_CONFIG_HOME?.trim();
+  if (explicit) return resolve(explicit);
+  const xdg = environment.XDG_CONFIG_HOME?.trim();
+  if (xdg) return resolve(join(xdg, "balladeer"));
+  return resolve(join(homedir(), ".config", "balladeer"));
+}
+function credentialsPath(environment = process.env) {
+  return join(configHome(environment), "credentials.json");
+}
+function assertPrivate(path, kind) {
+  const stats = lstatSync(path);
+  if (stats.isSymbolicLink()) {
+    throw new StoreError(
+      "credential_store_unsafe",
+      `${path} is a symbolic link. Balladeer will not follow one to write a credential.`
+    );
+  }
+  if ((stats.mode & 63) !== 0) {
+    throw new StoreError(
+      "credential_store_unsafe",
+      `${path} is readable by other users. Run: chmod ${kind === "directory" ? "700" : "600"} ${path}`
+    );
+  }
+}
+function storeAccessError(error, path, operation) {
+  if (error instanceof StoreError) return error;
+  const code = error?.code;
+  const permissionDenied = code === "EACCES" || code === "EPERM";
+  return new StoreError(
+    operation === "read" ? "credential_store_unreadable" : "credential_store_unwritable",
+    permissionDenied ? `Balladeer cannot ${operation} its local credential store at ${path}. Allow this command to access that private folder in your terminal or coding agent, then rerun the same command. Existing saved credentials were not replaced.` : `Balladeer could not ${operation} its local credential store at ${path} (${code ?? "filesystem error"}). Check that this location is a private, accessible directory, then retry. Existing saved credentials were not replaced.`,
+    { cause: error }
+  );
+}
+function readCredentials(environment = process.env) {
+  const path = credentialsPath(environment);
+  let raw;
+  try {
+    assertPrivate(path, "file");
+    raw = readFileSync(path, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return { ...EMPTY, pendingPairings: [], sessions: [], agents: [] };
+    }
+    throw storeAccessError(error, path, "read");
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      version: 1,
+      pendingPairings: Array.isArray(parsed.pendingPairings) ? parsed.pendingPairings : [],
+      sessions: Array.isArray(parsed.sessions) ? parsed.sessions : [],
+      agents: Array.isArray(parsed.agents) ? parsed.agents : []
+    };
+  } catch {
+    throw new StoreError(
+      "credential_store_unreadable",
+      `${path} is not valid JSON. Balladeer will not overwrite a file it cannot read.`
+    );
+  }
+}
+
+// src/guidance.ts
+import { createHash, randomBytes } from "node:crypto";
+import {
+  constants,
+  closeSync as closeSync2,
+  fstatSync,
+  lstatSync as lstatSync2,
+  mkdirSync as mkdirSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync
+} from "node:fs";
+import { join as join2 } from "node:path";
+var GUIDANCE_UNAVAILABLE = "Balladeer could not verify the current workspace guidance and capture mode. Continue the user's authorized work, but do not make unsolicited capture offers or file inferred promises. Do not reuse earlier Quiet/Thorough permission or cached instructions as current. An explicit request to record still requires current Balladeer tool checks and named-human agreement to meaning; never invent approval. Retry current guidance at the next hook boundary.";
+var HEX = /^[a-f0-9]{64}$/;
+var UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i;
+var MAX_BYTES = 4e4;
+var sha = (value) => createHash("sha256").update(value).digest("hex");
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseGuidance(value, agent) {
+  if (!object(value) || Object.keys(value).sort().join(",") !== "captureStyle,digest,instructions,repositoryId,revision,schemaVersion,workspaceId" || value.schemaVersion !== 1 || value.workspaceId !== agent.workspaceId || value.repositoryId !== agent.repositoryId || typeof value.revision !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._/-]{0,127}$/.test(value.revision) || typeof value.digest !== "string" || !HEX.test(value.digest) || !["quiet", "thorough", "off"].includes(String(value.captureStyle)) || typeof value.instructions !== "string" || value.instructions.length === 0 || value.instructions.length > 8e3 || sha(value.instructions) !== value.digest) {
+    throw new Error("invalid_guidance");
+  }
+  return value;
+}
+function guidanceEndpoint(agent) {
+  const url = new URL(agent.mcpUrl);
+  const expected = new URL(agent.controlPlane);
+  if (url.origin !== expected.origin || url.protocol !== "https:" || url.pathname !== "/api/mcp" || url.username || url.password || url.hash || !UUID.test(agent.workspaceId) || !UUID.test(agent.repositoryId))
+    throw new Error("invalid_guidance_scope");
+  for (const [key, value] of [
+    ["workspaceId", agent.workspaceId],
+    ["repositoryId", agent.repositoryId]
+  ]) {
+    if (url.searchParams.getAll(key).length > 1 || url.searchParams.has(key) && url.searchParams.get(key) !== value)
+      throw new Error("invalid_guidance_scope");
+    url.searchParams.set(key, value);
+  }
+  url.pathname = "/api/agent-guidance";
+  return url;
+}
+function readJson(path) {
+  let fd;
+  try {
+    fd = openSync2(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.size > MAX_BYTES || (stat.mode & 63) !== 0) return void 0;
+    return JSON.parse(readFileSync2(fd, "utf8"));
+  } catch {
+    return void 0;
+  } finally {
+    if (fd !== void 0) closeSync2(fd);
+  }
+}
+function privateDirectory(path) {
+  try {
+    mkdirSync2(path, { mode: 448 });
+  } catch {
+  }
+  const stat = lstatSync2(path);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 63) !== 0)
+    throw new Error("cache_unavailable");
+}
+function atomicJson(path, value) {
+  const temporary = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+  try {
+    writeFileSync(temporary, `${JSON.stringify(value)}
+`, { flag: "wx", mode: 384 });
+    renameSync2(temporary, path);
+  } finally {
+    try {
+      unlinkSync2(temporary);
+    } catch {
+    }
+  }
+}
+function guidanceScopeKey(agent) {
+  return sha(
+    JSON.stringify([
+      new URL(agent.controlPlane).origin,
+      sha(agent.token),
+      agent.workspaceId,
+      agent.repositoryId,
+      1
+    ])
+  );
+}
+function cacheDirectory(environment) {
+  const home = configHome(environment);
+  privateDirectory(home);
+  const directory = join2(home, "guidance-v1");
+  privateDirectory(directory);
+  return directory;
+}
+function cached(directory, scopeKey, agent) {
+  try {
+    const pointer = readJson(join2(directory, `${scopeKey}.current.json`));
+    if (!object(pointer) || typeof pointer.key !== "string" || !HEX.test(pointer.key))
+      return void 0;
+    const body = readJson(join2(directory, `${pointer.key}.body.json`));
+    if (!object(body) || typeof body.etag !== "string" || !/^"[a-f0-9]{64}"$/.test(body.etag))
+      return void 0;
+    const document = parseGuidance(body.document, agent);
+    if (pointer.key !== sha(JSON.stringify([scopeKey, document.revision]))) return void 0;
+    return { document, etag: body.etag, key: pointer.key };
+  } catch {
+    return void 0;
+  }
+}
+async function boundedBody(response) {
+  const declared = Number(response.headers.get("content-length") ?? 0);
+  if (declared > MAX_BYTES) throw new Error("guidance_oversized");
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("guidance_empty");
+  const buffers = [];
+  let bytes = 0;
+  try {
+    while (true) {
+      const part = await reader.read();
+      if (part.done) break;
+      bytes += part.value.byteLength;
+      if (bytes > MAX_BYTES) throw new Error("guidance_oversized");
+      buffers.push(part.value);
+    }
+    return JSON.parse(Buffer.concat(buffers).toString("utf8"));
+  } finally {
+    await reader.cancel().catch(() => void 0);
+  }
+}
+async function loadGuidance(input) {
+  const scopeKey = guidanceScopeKey(input.agent);
+  let directory;
+  try {
+    directory = cacheDirectory(input.environment);
+  } catch {
+  }
+  const previous = directory ? cached(directory, scopeKey, input.agent) : void 0;
+  const abort = new AbortController();
+  let timer;
+  try {
+    const task = async () => {
+      const response = await (input.fetchImpl ?? fetch)(guidanceEndpoint(input.agent), {
+        method: "GET",
+        redirect: "manual",
+        signal: abort.signal,
+        headers: {
+          authorization: `Bearer ${input.agent.token}`,
+          [CLIENT_HEADER]: CLIENT_HEADER_VALUE,
+          accept: "application/json",
+          ...previous ? { "if-none-match": previous.etag } : {}
+        }
+      });
+      if (response.status === 304) {
+        if (!previous || response.headers.get("etag") !== previous.etag || response.headers.get("x-balladeer-guidance-revision") !== previous.document.revision) {
+          throw new Error("invalid_guidance_revalidation");
+        }
+        return { status: "revalidated", document: previous.document, scopeKey };
+      }
+      if (response.status !== 200) {
+        await response.body?.cancel();
+        throw new Error("guidance_unavailable");
+      }
+      const document = parseGuidance(await boundedBody(response), input.agent);
+      const etag = response.headers.get("etag");
+      if (!etag || !/^"[a-f0-9]{64}"$/.test(etag) || response.headers.get("x-balladeer-guidance-revision") !== document.revision)
+        throw new Error("invalid_guidance_headers");
+      if (abort.signal.aborted) throw new Error("guidance_deadline");
+      if (directory) {
+        try {
+          const key = sha(JSON.stringify([scopeKey, document.revision]));
+          atomicJson(join2(directory, `${key}.body.json`), { document, etag });
+          atomicJson(join2(directory, `${scopeKey}.current.json`), { key });
+          if (previous && previous.key !== key) {
+            try {
+              unlinkSync2(join2(directory, `${previous.key}.body.json`));
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+      return { status: "fresh", document, scopeKey };
+    };
+    return await Promise.race([
+      task(),
+      new Promise((_, reject) => {
+        timer = setTimeout(
+          () => {
+            abort.abort();
+            reject(new Error("guidance_deadline"));
+          },
+          Math.min(input.timeoutMs ?? 1e3, 1e3)
+        );
+      })
+    ]);
+  } catch {
+    abort.abort();
+    return { status: "unavailable", scopeKey };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function recordGuidanceContext(input, write) {
+  const always = input.event !== "UserPromptSubmit" || input.load.status === "unavailable" || !input.sessionId;
+  const contextKey = sha(
+    JSON.stringify([
+      input.scopeKey,
+      input.hook,
+      input.sessionId ?? randomBytes(16).toString("hex"),
+      input.agentId ?? "root"
+    ])
+  );
+  const document = input.load.document;
+  let path;
+  let emitted = true;
+  try {
+    path = join2(cacheDirectory(input.environment), `${contextKey}.context.json`);
+    const previous = readJson(path);
+    emitted = always || !object(previous) || previous.status === "unavailable" || previous.digest !== document?.digest || previous.revision !== document?.revision || (previous.runtimeGeneration ?? null) !== (input.runtimeGeneration ?? null);
+  } catch {
+  }
+  if (!emitted) return false;
+  write();
+  if (path) {
+    try {
+      atomicJson(path, {
+        schemaVersion: 1,
+        contextKey,
+        event: input.event,
+        status: input.load.status,
+        digest: document?.digest ?? null,
+        revision: document?.revision ?? null,
+        runtimeGeneration: input.runtimeGeneration ?? null,
+        emitted: true,
+        emittedAt: new Date(input.now ?? Date.now()).toISOString()
+      });
+    } catch {
+    }
+  }
+  return true;
+}
+
+// src/guidance-install.ts
+import { execFileSync } from "node:child_process";
+import {
+  constants as constants2,
+  closeSync as closeSync5,
+  fstatSync as fstatSync2,
+  openSync as openSync5,
+  existsSync as existsSync2,
+  lstatSync as lstatSync4,
+  linkSync,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync5,
+  renameSync as renameSync5,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+var import_toml2 = __toESM(require_toml(), 1);
+import { dirname as dirname3, join as join5, relative } from "node:path";
+
+// src/codex-config.ts
+var import_toml = __toESM(require_toml(), 1);
+import {
+  closeSync as closeSync4,
+  existsSync,
+  fsyncSync as fsyncSync3,
+  lstatSync as lstatSync3,
+  mkdirSync as mkdirSync3,
+  openSync as openSync4,
+  readFileSync as readFileSync4,
+  renameSync as renameSync4,
+  unlinkSync as unlinkSync4,
+  writeSync as writeSync3
+} from "node:fs";
+import { join as join4 } from "node:path";
+
+// src/mcp-config.ts
+import {
+  closeSync as closeSync3,
+  fsyncSync as fsyncSync2,
+  openSync as openSync3,
+  readFileSync as readFileSync3,
+  renameSync as renameSync3,
+  unlinkSync as unlinkSync3,
+  writeSync as writeSync2
+} from "node:fs";
+import { basename, dirname as dirname2, isAbsolute, join as join3 } from "node:path";
+
+// src/release.ts
+var PUBLISHED_SPECIFIER = "balladeer@latest";
+
+// src/mcp-config.ts
+var MCP_CONFIG_FILE = ".mcp.json";
+function sameOrigin(left, right) {
+  try {
+    return new URL(left).origin === new URL(right).origin;
+  } catch {
+    return false;
+  }
+}
+function isNodeCommand(command) {
+  const name = basename(command);
+  return name === "node" || name === "node.exe";
+}
+function isOurEntry(entry, controlPlane) {
+  if (entry === null || typeof entry !== "object") return false;
+  const record = entry;
+  if (typeof record.url === "string") return sameOrigin(record.url, controlPlane);
+  if (typeof record.command !== "string" || !Array.isArray(record.args)) return false;
+  const args = record.args;
+  if (record.command === "npx") {
+    const specifier = args[1];
+    return typeof specifier === "string" && /^balladeer@(?:latest|\d+\.\d+\.\d+)$/.test(specifier) && args[2] === "mcp";
+  }
+  if (isNodeCommand(record.command)) {
+    const script = args[0];
+    return typeof script === "string" && isAbsolute(script) && basename(script) === "cli.js" && args[1] === "mcp";
+  }
+  return false;
+}
+function entryRepositoryId(entry) {
+  const args = entry?.args;
+  if (!Array.isArray(args)) return void 0;
+  const at = args.indexOf("--repository");
+  const value = at === -1 ? void 0 : args[at + 1];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function currentEntry(parsed) {
+  const servers = parsed?.mcpServers;
+  if (servers === null || typeof servers !== "object") return void 0;
+  return servers.balladeer;
+}
+function readMcpConfig(repositoryRoot) {
+  try {
+    return JSON.parse(readFileSync3(join3(repositoryRoot, MCP_CONFIG_FILE), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+
+// src/codex-config.ts
+var CODEX_CONFIG_FILE = ".codex/config.toml";
+function readCodexEntry(root) {
+  try {
+    const config = (0, import_toml.parse)(readFileSync4(join4(root, CODEX_CONFIG_FILE), "utf8"));
+    const servers = config.mcp_servers;
+    return servers && typeof servers === "object" && !Array.isArray(servers) && !(servers instanceof Date) ? servers.balladeer : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function hasManagedCodexEntry(root, controlPlane) {
+  try {
+    const text = readFileSync4(join4(root, CODEX_CONFIG_FILE), "utf8");
+    const starts = [...text.matchAll(/^# balladeer:mcp:start\r?$/gm)];
+    const ends = [...text.matchAll(/^# balladeer:mcp:end\r?$/gm)];
+    if (starts.length !== 1 || ends.length !== 1 || !starts[0] || !ends[0] || starts[0].index >= ends[0].index)
+      return false;
+    const block = (0, import_toml.parse)(text.slice(starts[0].index + starts[0][0].length, ends[0].index));
+    const servers = block.mcp_servers;
+    if (Object.keys(block).length !== 1 || !servers || typeof servers !== "object" || Array.isArray(servers) || servers instanceof Date || Object.keys(servers).length !== 1)
+      return false;
+    const own = readCodexEntry(root);
+    return isOurEntry(own, controlPlane) && JSON.stringify(own) === JSON.stringify(servers.balladeer);
+  } catch {
+    return false;
+  }
+}
+
+// src/copy.ts
+var RETRIEVAL_SCOPE = `### Reading what is already agreed
+
+Retrieve by promise, and only when this session has a reason to. One repository here can hold a
+thousand agreed promises, and a plan built from whatever survived a truncated catalog read is worse
+than a plan built from none of it, because nothing tells you which half went missing.
+
+When a person gives you a promise id, expand exactly that one with get_promise and stop there. Every
+promise page carries a control that copies its id, so an id is what a person hands you when they
+mean a particular promise. Ask for one rather than searching for what they meant.
+
+Consult list_promises in two situations and no others. The person asks what this repository has
+promised, in which case page the index they asked for. Or the change you are about to make touches
+paths that carry promises, in which case give those paths to list_promises: it answers with the
+promises whose scope overlaps them, closest first, and with the few that name no path and so cover
+the whole repository. That answer is a selection rather than a page and does not continue with a
+cursor, so when the total beside it is larger than what you were handed, narrow the paths rather
+than asking for more.
+
+When you do not yet know which paths you are about to touch, do not call the index at all. Work from
+ids until you do, because a page you did not ask a question of is not about your change, and reading
+one as though it were is how a plan quietly misses the promise it breaks.
+
+To learn which paths those are, read \`paths\` on a list_promises answer you asked for
+without paths of your own. It is the set of
+repository paths this repository's promises are scoped to, deduplicated and bounded, with
+\`pathsTruncated\` saying whether there were more than the answer carries. Compare the files you are
+about to change against it. Nothing matching means there is nothing here to read, and saying so is a
+better answer than a page of promises about somewhere else.
+
+Never call get_promise_context at the start of a session. It answers the markers you give it, and
+before you know what you are changing there are no markers to give: what comes back is a slice of
+the catalog chosen by nothing. Call it once the work is in front of you, with that work's markers.
+
+Every one of these reads is bounded and none of them returns the whole catalog. Read the total
+beside the rows and the sentence in \`scope\` that says what the total is a total of, and when the
+total is larger than what you were handed, page or narrow rather than planning as though you had
+seen everything.`;
+var SESSION_BEHAVIORS = `### Three things to offer without being asked
+
+At the start of any session in this repository, before you plan anything, ask list_promises for the
+promises nothing is checking yet that belong to the person you are working with: \`unverified\` true
+and \`mine\` true, which is one bounded read rather than the catalog. If it returns any, say so in one
+line and offer to build their verifiers now. Name each one by its one-sentence claim rather than by
+an id, so the person can see which behavior is unguarded. Ask the same tool for
+\`brokenSinceLastSeen\` true as well, and where that returns any, say in one line that those promises
+broke since they last looked, name each by its claim, and offer to fix them. Then wait for their
+answer. The offer is the whole of it, and never start building or repairing one because nobody said
+no.
+
+Theirs, and nobody else's. \`mine\` keeps the promises this person owns or agreed to, and a teammate's
+unguarded promise is that teammate's to hear about: a session that opens by reading out other
+people's unfinished work reads as an audit of them. \`brokenSinceLastSeen\` is that person's own by
+construction and needs no \`mine\` beside it. Drop \`mine\` when this person asks what the rest of the
+team has promised, and say whose promises you are showing them when you do.
+
+When you have proposed promises, show them here as well as there. Put each proposal in the
+conversation in full: its one-sentence claim, who it is for, when it applies and what must then be
+true, and the numbered cases that must keep working and the ones that must be caught. Do not
+store or present an unanswered-question backlog. Then offer to finish the agreement from here, by asking for a sign-off, giving them
+the page it returns and taking the one-time code that page shows them, so the browser is needed only
+for signing. Give them the review link in the same message too, because some people would rather
+read it there and edit it before they agree.
+A promise whose meaning is agreed and which nothing is checking yet is one you can finish. When
+somebody gives you a promise id, run \`balladeer status <promise id>\`, or expand it with get_promise.
+If it comes back agreed with nothing checking it, say so in one line and offer to prepare and build
+its verifier now. Only if they say yes: \`prepare_qualification\` mints the one-time setup, or
+\`balladeer prepare <promise id>\` mints it and writes it where the sealed run reads it. You need no
+sign-off for that and there is no code to ask anybody for, because agreeing the meaning was their
+act and building the check that proves it is yours. Then build the verifier, seal it, push, and tell
+them protection starts by itself when that run qualifies. The offer is the whole of it: never
+prepare one because nobody said no.`;
+var CAPTURE_SEAM = `### When to offer, and what a yes is worth
+
+Notice durable customer behavior during ordinary work. Offer to preserve a concrete behavior
+beside useful work, without blocking implementation. File nothing until the person explicitly
+asks you to record it or accepts a scoped capture offer. A factual answer or permission to build
+alone is not permission to record. A no ends that offer; do not raise it again in this conversation.
+
+Do not offer while the user is comparing options or exploring without a decision. If they later
+choose a concrete behavior, you may offer to capture it even though the conversation began as
+exploration. Do not offer new promises for pure refactors or cosmetic changes. During an active
+production incident, prioritize recovery and defer capture until recovery. Ordinary bug fixing
+is not automatically an active production incident.
+
+For clear feature intent, an offer before implementation can make the promise a target for the
+work. For a normal bug fix, offer alongside the completed fix and checks. Neither requires a
+merge or another human closing reply. If the user is away, one nonblocking offer can remain in
+your completion message for their return; do not file or wait for an answer.
+
+Use available context to state a specific behavior. A precise capture offer can confirm your
+interpretation and obtain permission to record in one yes. Ask a separate work question only
+when a consequential choice remains that a clear, scoped offer cannot resolve. An unanswered
+earlier question is not itself a reason to ask again. The server supplies current detailed guidance.
+
+### Two promises Balladeer cannot keep
+
+A promise about speed needs three things before it is a promise at all: a number, a percentile, and
+where it is measured. "The quote page answers in under one second at p95, measured in production at
+peak load" is one Balladeer can keep. "The quote page has to be fast" is not. Say this, and ask for
+the part that is missing rather than filing it:
+
+"I can keep that once it has a number, a percentile, and a place it is measured. Without those it is
+a wish, not a promise."
+
+Balladeer refuses one without all three and names which of them is missing. When all three are
+there, write the measurement method into the promise, and tell them plainly that it reads agreed and
+unprotected until a test that actually measures it exists.
+
+A promise about how the team works is not something the software does, so no check can ever catch
+it. "We must provide a low-friction capture experience" is one of these. File nothing and say:
+
+"That is a promise about how we work, not something the software does that a check can fail.
+Balladeer only keeps promises a check can catch. If a customer would notice something when this
+slips, say that and I will keep that instead."
+
+Then take the customer-visible half if they give you one, and file that instead.`;
+var SETTLING_QUESTIONS = `### When somebody says "tell me about" one
+
+An id is how a person points at something here. Expand a promise id with get_promise and a proposal
+id with get_proposal. Describe who it is for, when it applies, the behavior and the concrete cases.
+A proposal awaits its named owner's agreement; a promise is agreed and may still be unprotected.
+Previously recorded answers are historical reasoning, not a new interview or an approval.
+If the person wants a change, clarify the changed commitment before writing it. Preserve all other
+meaning and cases. An agreed promise changes only through a revision its named owner approves.`;
+var FETCH_BUDGET = `Fetch by id, and only for an id the person gave you or an index row whose paths match the change in
+front of you. Never enumerate the catalog. Never chain one fetch into the next to see the whole of
+something: when the rows do not settle it, narrow the filter rather than expanding another promise.`;
+var SEALED_FILES = `### Files that are sealed, and the one reason to edit one
+
+Every file under .continuity/promises/ is sealed. The promise that owns that directory records the
+exact bytes of each file in it, so editing one, adding one there, renaming one or deleting one
+breaks the seal. A promise whose seal is broken stops being checked, and it stays that way until a
+named person qualifies it again, which is their afternoon rather than your commit. Nothing in there
+is ordinary source: keep it out of refactors, formatting runs and dependency upgrades.
+
+Find out which directories are sealed before you plan an edit, not after. balladeer status lists
+them, and list_promises names a promise's sealed directory on its row once a verifier is bound to
+it. Then, before you push, run balladeer check-seals. It prints nothing and exits zero when your
+change touches no seal, and names the promise, its owner and its page when your change would break
+one.
+
+The one reason to edit a sealed file is to repair a verifier that can no longer run: something it
+imports moved, or the language it is written in changed under it. Never edit one to make a failing
+check pass. A check going red is the promise doing its job, and the repair for that belongs in the
+behavior it protects. A repair is not finished until the promise is sealed again with the runner
+this repository is pinned to. get_promise_setup carries that exact seal command, and
+balladeer check-seals prints it beside any promise it names.`;
+var TOUCH_MAP_GUIDANCE = `Prefer the measurement over the markers. Where this repository has a touch map, \`balladeer affected
+<paths...>\` answers which promises ran the files in front of you, out of what each verifier actually
+executed the last time \`balladeer touch-map\` measured it. Both commands run on this machine and
+send Balladeer nothing, so you may name any path in the change.
+
+An answer marked stale was measured against a verifier that has changed since, so read it as the
+last thing anybody measured rather than as fact, and offer to run \`balladeer touch-map\` again.
+Where there is no map, where it does not name your paths, or where it reports a promise it could not
+measure, fall back to the paths on the index rows. The map narrows which promises are worth
+fetching. It never widens what you may read: the catalog is still never enumerated, and the fetch
+budget is unchanged.
+
+When a retrieval receipt asks why you read a row, the answer for one the map named is \`touch\`.`;
+var SESSION_STAMP = `Use the installed \`balladeer\` command after setup reports CLI readiness. If it is missing from
+PATH (including an older 1.0.4 setup), use \`npx -y balladeer@latest <command>\` for that invocation
+and read the current /agent instructions for installation or repair. Do not claim that an older
+repository's instructions were refreshed. CLI availability does not prove that this coding host
+loaded the native MCP tools or that a credential is authorized. The optional session stamp below
+is separate from all three.
+
+Run \`balladeer session\` when you start work here and pass the id it prints to every promise read
+you make, as \`session\`. It is the same id for the whole of one piece of work, and it costs nothing:
+a read without it is answered exactly the same way.
+
+If local file permissions refuse that session write, no session stamp was saved. Your saved
+connection is unchanged; this does not prove its current server authorization. Continue
+already-authorized MCP reads, coding and explicitly requested capture without the optional
+\`session\` field. Do not invent an ID, add a session trailer, or record an unsaved stamp. Do not
+broaden filesystem access or move credentials to retry this write. A missing credential or server
+authorization refusal is different: follow that refusal. Capture still needs the person's request
+or accepted offer, and human meaning approval is unchanged.
+
+If a session ID was saved, near the end of the work call \`mark_promise_used\` with the ids you actually cited
+or acted on. Naming none is a fine answer. It is the only way anybody finds out which rows were
+worth sending you, because reading a promise and then ignoring it is not the same as using it.
+
+If a session ID was saved, write \`Balladeer-Session: <the id>\` into the commit message or pull-request body you produce,
+and run \`balladeer session --record\` once the commit exists. That is what lets a check that goes red
+next week be read back against what Balladeer told you before you started. Your commit message never
+leaves your machine: only the session id and the commit SHA are sent.`;
+var WORKFLOW_GUIDANCE = `## Balladeer promises
+
+Before planning work in this repository, read the promises this team has already approved through
+the Balladeer MCP server. They are the behaviors a named person has agreed the software keeps, so
+your plan has to hold them, not just read them.
+
+${RETRIEVAL_SCOPE}
+
+Each index row carries what it takes to rule that promise out without fetching it: the repository,
+the paths it covers, its one-sentence claim, what protects it and why, and when anything last
+checked it.
+
+${TOUCH_MAP_GUIDANCE}
+
+${FETCH_BUDGET}
+
+${CAPTURE_SEAM}
+
+${SESSION_STAMP}
+
+### When somebody asks you to protect a behavior
+
+A request to build a behavior is not permission to record it. An explicit request to preserve it
+or acceptance of a specific capture offer permits one pending proposal for that behavior, not
+other behaviors you notice. A factual answer alone does not authorize recording.
+
+Use available conversation and repository context before asking questions. A precise capture
+offer can state your interpretation and obtain permission to record it in one yes. Ask separately
+only when a consequential choice remains that the scoped offer cannot resolve. Do not ask for
+known facts, repeat a question resolved by later context or acceptance, or require a formal
+must-not sentence from the user. Preserve their actual words separately from your interpretation.
+If no specific commitment is possible yet, continue the authorized work without filing it.
+
+Use relevant existing promises already retrieved, or the bounded repository/path lookup, to notice
+concrete conflicts before writing. If the same situation would require incompatible outcomes, show
+the two commitments and ask which behavior they intend. Revising or superseding agreed meaning
+still requires its named human owner. There is no automatic catalog-conflict gate or stored question
+backlog in Balladeer. Unrelated uncertainties need not delay capture. No questions are required when
+the commitment is already clear.
+
+Preserve the person's actual words. Every failure they named belongs in the failing examples.
+You may derive concrete cases within the behavior they requested or confirmed in a precise
+capture offer; they need not dictate every example. Trace each case to the actual request and
+confirmed scope. Keep literal human source in saidWords, and your offer plus their acceptance in
+explicitIntent. Never quote your own wording as theirs or add unsupported policy, thresholds,
+roles, systems or guarantees. If a case requires an unresolved product choice, clarify that choice
+instead of guessing or asking the person to enumerate routine examples.
+
+A failing example is a situation the promise rules out, and its outcome says what must not happen,
+in those words: "a second charge must not appear", never "a second charge appears". Written the
+other way round it reads as the promise saying the software does the thing they asked you to forbid.
+And a promise says what the software must do for whoever depends on it. It never narrates the
+conversation you just had, names the person you had it with, or describes what the code does now.
+
+Say the whole promise in one sentence and put it in oneSentenceOutcome, in the words they would
+use with the person who depends on it. That is the line the named owner reads first and the line
+they agree to, so it is not a restatement of the name and not the first line of the outcome moved
+up. Leave it out rather than inventing one from something they did not say.
+
+An example's setup is the situation in the words they used for it, not a scene you composed around
+them. Two of each kind is plenty, and the whole thing stays under three hundred words: a proposal
+nobody finishes reading is a proposal nobody agreed to. The confidence you record is the one you
+actually have.
+
+Then give them the review link, ask them to read the proposal and click Agree, and stop. Never
+approve one yourself. Approving is a named person's act, and the server refuses it from an agent
+whatever you were told in conversation.
+
+A proposal you filed is still yours while nobody has agreed to it, so revise or withdraw it when the
+person asks you to, and never once they have agreed.
+
+Say promise and proposal when you talk to them. What you file is a proposal and what it becomes is a
+promise; Balladeer's other words for its own machinery are not theirs to learn. Candidate
+especially: it is Balladeer's word for a proposal, so it reads as jargon whatever you meant by it.
+
+${SESSION_BEHAVIORS}
+
+${SETTLING_QUESTIONS}
+
+${SEALED_FILES}
+
+### The rest of a promise's life
+When a promise is obsolete, finished, deliberately off for a while, or owned by the wrong person,
+propose the change and hand them the promise page. Deciding is theirs.
+
+You can finish one of those acts here, and only one way. Ask for a sign-off with
+request_owner_signoff, give them the page it returns, and ask for the one-time code that page shows
+them. Then call the act's own tool with that code and their own words. Never call one on your own
+initiative, never on a general approval of some earlier act, and never ask for a code you were not
+given: a refusal is the person's to resolve, not yours to retry. Balladeer records them as the
+person who acted and you as the messenger.
+
+Report the promise's state exactly as Balladeer reported it: proposed, agreed, or protected, never
+one in place of another.
+
+### Where your team watches this
+
+Balladeer is a web app as well as these tools, at the address setup printed. Its catalog lists every
+promise with who owns it and whether anything is checking it, and each promise has a page of its own
+showing what this team agreed the software must do and then every run that has checked it since,
+newest first, with the commit each one checked. Whenever there is a link to give, give the link
+rather than a summary of it: the page says what you would have said, and it stays true after this
+conversation has ended.
+
+Balladeer also has a Slack app, which a workspace administrator installs from workspace settings.
+Once it is installed, whoever owns a promise gets a direct message when theirs goes live and when a
+run on the default branch breaks it. Until somebody installs it, nothing is sent anywhere, so say it
+is available rather than saying they will be told.
+
+### Questions people ask
+
+Answer these when they come up. Where you do not know, say so and point at the address setup
+printed: a confident wrong answer about what a vendor can see is worse than no answer.
+
+What it does: it holds the behaviors this team has agreed the software must keep, and reports
+whether each one is still being kept, from this repository's own tests running in its own CI.
+
+What it sees: the text of each promise somebody approves, this repository's numeric ids and the name
+of its default branch, and from CI the pass or fail outcome, the commit checked, and content hashes.
+Never the code, the tests, the fixtures, the logs, the prompts, or the transcripts.
+
+What stopping costs: nothing that matters to their tests. The verifier package, its fixtures and the
+workflow file are theirs, in their repository, running in their CI, and disconnecting changes none
+of them. An administrator can download everything Balladeer holds at any time from workspace
+settings, and disconnecting hands them that same download in the response that ends access.
+
+Who can approve one: the named person who owns it, in their own browser. Not an administrator on
+their behalf, and never you.
+
+Whether it blocks a merge: no. The check is advisory on Balladeer's side, and their own branch
+protection is what decides whether a failing check stops anything.
+
+Who can invite people and change setup: a workspace administrator. A contributor can read the
+workspace and propose promises, and a viewer can read it. If somebody asks you to add a teammate,
+invite_teammate returns the page an administrator sends the invitation from, with the address filled
+in for them to read. The tool sends nothing itself: an administrator presses Send.`;
+
+// src/guidance-install.ts
+var MAX_FILE = 262144;
+function readRegular(path, allowMissing = false, writable = true) {
+  if (!existsSync2(path)) {
+    try {
+      lstatSync4(path);
+    } catch (e) {
+      if (e.code === "ENOENT" && allowMissing) return void 0;
+    }
+    throw new Error("file_unavailable");
+  }
+  const stat = lstatSync4(path);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_FILE || writable && (stat.mode & 146) === 0)
+    throw new Error("file_not_safely_writable");
+  return readFileSync5(path, "utf8");
+}
+function safeParent(root, path) {
+  let at = dirname3(path);
+  while (at !== root) {
+    if (relative(root, at).startsWith("..")) throw new Error("outside_repository");
+    try {
+      const stat = lstatSync4(at);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("unsafe_directory");
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+    at = dirname3(at);
+  }
+}
+function validateProjectGuidanceScope(options) {
+  try {
+    const root = execFileSync("git", ["-C", options.cwd, "rev-parse", "--show-toplevel"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1e3
+    }).trim();
+    const path = join5(root, options.hook === "codex" ? ".codex/config.toml" : ".mcp.json");
+    safeParent(root, path);
+    readRegular(path, false, false);
+    const entry = options.hook === "codex" ? readCodexEntry(root) : currentEntry(readMcpConfig(root));
+    if (!isOurEntry(entry, options.controlPlane) || entryRepositoryId(entry) !== options.repositoryId)
+      return false;
+    if (options.hook === "codex" && !hasManagedCodexEntry(root, options.controlPlane)) return false;
+    const args = entry.args;
+    if (!Array.isArray(args)) return false;
+    const at = args.indexOf("--control-plane");
+    return at === -1 ? options.controlPlane === DEFAULT_CONTROL_PLANE : args[at + 1] === options.controlPlane;
+  } catch {
+    return false;
+  }
+}
+
+// src/agent.ts
+var REPOSITORY_NAME = /^[A-Za-z0-9._-]{1,39}\/[A-Za-z0-9._-]{1,100}$/;
+function selectAgent(agents, controlPlane, repositoryId, currentRepository) {
+  const here = agents.filter((agent) => agent.controlPlane === controlPlane);
+  if (repositoryId !== void 0) {
+    const named = here.find(
+      (agent) => agent.repositoryId === repositoryId || agent.repository?.toLowerCase() === repositoryId.toLowerCase()
+    );
+    if (named === void 0) {
+      return {
+        kind: "refused",
+        reason: `No Balladeer connection for repository ${repositoryId} is stored for ${controlPlane}.`,
+        missingFor: repositoryId
+      };
+    }
+    return withSafeEndpoint(named);
+  }
+  if (!REPOSITORY_NAME.test(currentRepository) || currentRepository === "unknown/unknown") {
+    return {
+      kind: "refused",
+      reason: "This directory has no GitHub origin remote I could read, so I cannot tell which repository's Balladeer connection to use. Pass --repository <id>."
+    };
+  }
+  const matches = here.filter(
+    (agent) => agent.repository?.toLowerCase() === currentRepository.toLowerCase()
+  );
+  const chosen = matches[matches.length - 1];
+  if (chosen === void 0) {
+    return {
+      kind: "refused",
+      reason: `No Balladeer connection for ${currentRepository} is stored for ${controlPlane}.`,
+      missingFor: currentRepository
+    };
+  }
+  return withSafeEndpoint(chosen);
+}
+function withSafeEndpoint(agent) {
+  try {
+    if (new URL(agent.mcpUrl).origin !== new URL(agent.controlPlane).origin) {
+      return {
+        kind: "refused",
+        reason: "That connection's MCP endpoint is not on the control plane it belongs to, so I sent its credential nowhere."
+      };
+    }
+  } catch {
+    return {
+      kind: "refused",
+      reason: "That connection's MCP endpoint is not a URL, so I did not use it."
+    };
+  }
+  return { kind: "agent", agent };
+}
+
+// src/repository.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+var REPOSITORY_HINT_PATTERN = /^[A-Za-z0-9._-]{1,39}\/[A-Za-z0-9._-]{1,100}$/;
+function repositoryHint(cwd = process.cwd()) {
+  let remote;
+  try {
+    remote = execFileSync2("git", ["-C", cwd, "remote", "get-url", "origin"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return "unknown/unknown";
+  }
+  const match = /github\.com[:/]+([A-Za-z0-9._-]{1,39})\/([A-Za-z0-9._-]{1,100}?)(?:\.git)?$/.exec(
+    remote
+  );
+  if (!match) return "unknown/unknown";
+  const hint = `${match[1]}/${match[2]}`;
+  return REPOSITORY_HINT_PATTERN.test(hint) ? hint : "unknown/unknown";
+}
+
+// src/quiet.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync6, realpathSync } from "node:fs";
+import { join as join6 } from "node:path";
+var EMPTY2 = { schemaVersion: 1, folders: [], remotes: [] };
+function quietPath(environment = process.env) {
+  return join6(configHome(environment), "quiet.json");
+}
+function readQuiet(environment = process.env) {
+  const path = quietPath(environment);
+  if (!existsSync3(path)) return EMPTY2;
+  try {
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    if (parsed.schemaVersion !== 1) return EMPTY2;
+    return {
+      schemaVersion: 1,
+      folders: Array.isArray(parsed.folders) ? parsed.folders.filter(isString) : [],
+      remotes: Array.isArray(parsed.remotes) ? parsed.remotes.filter(isString) : []
+    };
+  } catch {
+    return EMPTY2;
+  }
+}
+var isString = (value) => typeof value === "string";
+function folderKey(cwd) {
+  try {
+    return realpathSync(
+      execFileSync3("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1e3
+      }).trim()
+    );
+  } catch {
+    return realpathSync(cwd);
+  }
+}
+function isQuiet(cwd, environment = process.env) {
+  const list = readQuiet(environment);
+  const folder = folderKey(cwd);
+  const remote = repositoryHint(cwd);
+  return list.folders.includes(folder) || remote !== "unknown/unknown" && list.remotes.some((r) => r.toLowerCase() === remote.toLowerCase());
+}
+
+// src/commands/guidance.ts
+function untrackedLine(remote) {
+  const here = remote === "unknown/unknown" ? "This folder" : `This folder (${remote})`;
+  return `${here} isn't tracked by Balladeer, so promises can't be tracked from here. To track it, run \`npx -y ${PUBLISHED_SPECIFIER} setup\` in this folder. To stop this message here, run \`npx -y ${PUBLISHED_SPECIFIER} quiet\` (or \`quiet --repo\` for the whole repository).`;
+}
+function readInput(stream) {
+  return new Promise((resolve2, reject) => {
+    let bytes = 0;
+    const chunks = [];
+    const finish = (error) => {
+      clearTimeout(timer);
+      stream.removeListener("data", data);
+      stream.removeListener("end", end);
+      stream.removeListener("error", failed);
+      stream.pause();
+      if (error) reject(error);
+      else {
+        try {
+          resolve2(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+        } catch {
+          reject(new Error("invalid_hook_input"));
+        }
+      }
+    };
+    const data = (chunk) => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      bytes += buffer.length;
+      if (bytes > 65536) finish(new Error("hook_input_oversized"));
+      else chunks.push(buffer);
+    };
+    const end = () => finish();
+    const failed = () => finish(new Error("hook_input_unavailable"));
+    const timer = setTimeout(() => finish(new Error("hook_input_deadline")), 250);
+    stream.on("data", data);
+    stream.once("end", end);
+    stream.once("error", failed);
+  });
+}
+function eventFrom(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return void 0;
+  const event = input.hook_event_name;
+  return event === "SessionStart" || event === "SubagentStart" || event === "UserPromptSubmit" ? event : void 0;
+}
+function identifier(input) {
+  return typeof input === "string" && input.length > 0 && input.length <= 256 ? input : void 0;
+}
+async function runGuidance(options) {
+  const projectScoped = options.repositoryId !== void 0;
+  if (projectScoped && !validateProjectGuidanceScope({
+    cwd: options.cwd,
+    hook: options.hook,
+    repositoryId: options.repositoryId,
+    controlPlane: options.controlPlane
+  }))
+    return 0;
+  let event = options.event ?? "SessionStart";
+  const emit = (context) => options.write(
+    `${JSON.stringify({
+      hookSpecificOutput: { hookEventName: event, additionalContext: context }
+    })}
+`
+  );
+  try {
+    const input = await readInput(options.stdin);
+    const parsedEvent = eventFrom(input);
+    if (!parsedEvent || options.event && parsedEvent !== options.event)
+      throw new Error("invalid_hook_event");
+    event = parsedEvent;
+    const record = input;
+    const credentials = readCredentials(options.environment).agents;
+    const agents = projectScoped ? credentials.filter(
+      (agent) => agent.controlPlane === options.controlPlane && agent.repositoryId === options.repositoryId
+    ) : (() => {
+      const selection = selectAgent(
+        credentials,
+        options.controlPlane,
+        void 0,
+        repositoryHint(options.cwd)
+      );
+      return selection.kind === "refused" ? [] : [selection.agent];
+    })();
+    if (agents.length !== 1 || !agents[0]) {
+      if (projectScoped) throw new Error("guidance_connection_unavailable");
+      if (event === "SessionStart" && !isQuiet(options.cwd, options.environment))
+        emit(untrackedLine(repositoryHint(options.cwd)));
+      return 0;
+    }
+    const loaded = await loadGuidance({
+      agent: agents[0],
+      environment: options.environment,
+      timeoutMs: 750,
+      ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
+    });
+    const sessionId = identifier(record.session_id);
+    const agentId = identifier(record.agent_id);
+    recordGuidanceContext(
+      {
+        environment: options.environment,
+        scopeKey: loaded.scopeKey,
+        hook: options.hook,
+        event,
+        ...options.runtimeGeneration ? { runtimeGeneration: options.runtimeGeneration } : {},
+        load: loaded,
+        ...sessionId ? { sessionId } : {},
+        ...agentId ? { agentId } : {},
+        ...options.now ? { now: options.now() } : {}
+      },
+      () => emit(
+        loaded.document ? `Current Balladeer guidance (${loaded.document.revision}). This supersedes earlier Balladeer workflow and capture guidance in this context.
+
+${loaded.document.instructions}` : GUIDANCE_UNAVAILABLE
+      )
+    );
+  } catch {
+    try {
+      emit(GUIDANCE_UNAVAILABLE);
+    } catch {
+    }
+  }
+  return 0;
+}
+export {
+  runGuidance
+};