agent-shim 8.31.0 → 8.33.0

package/dist/cli.cjs

@@ -13,9 +13,9 @@ var __commonJS = (cb, mod) => function __require() {
     throw mod = 0, e;
   }
 };
-var __export = (target, all2) => {
-  for (var name in all2)
-    __defProp(target, name, { get: all2[name], enumerable: true });
+var __export = (target, all3) => {
+  for (var name in all3)
+    __defProp(target, name, { get: all3[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -5369,17 +5369,17 @@ var require_parse = __commonJS({
           let output2 = ")";
           if (brace.dots === true) {
             const arr = tokens.slice();
-            const range = [];
+            const range2 = [];
             for (let i2 = arr.length - 1; i2 >= 0; i2--) {
               tokens.pop();
               if (arr[i2].type === "brace") {
                 break;
               }
               if (arr[i2].type !== "dots") {
-                range.unshift(arr[i2].value);
+                range2.unshift(arr[i2].value);
               }
             }
-            output2 = expandRange(range, opts);
+            output2 = expandRange(range2, opts);
             state.backtrack = true;
           }
           if (brace.comma !== true && brace.dots !== true) {
@@ -5747,9 +5747,9 @@ var require_picomatch = __commonJS({
     var utils = require_utils();
     var constants = require_constants();
     var isObject5 = (val) => val && typeof val === "object" && !Array.isArray(val);
-    var picomatch4 = (glob, options, returnState = false) => {
+    var picomatch3 = (glob, options, returnState = false) => {
       if (Array.isArray(glob)) {
-        const fns = glob.map((input2) => picomatch4(input2, options, returnState));
+        const fns = glob.map((input2) => picomatch3(input2, options, returnState));
         const arrayMatcher = (str) => {
           for (const isMatch of fns) {
             const state2 = isMatch(str);
@@ -5765,16 +5765,16 @@ var require_picomatch = __commonJS({
       }
       const opts = options || {};
       const posix = opts.windows;
-      const regex = isState ? picomatch4.compileRe(glob, options) : picomatch4.makeRe(glob, options, false, true);
+      const regex = isState ? picomatch3.compileRe(glob, options) : picomatch3.makeRe(glob, options, false, true);
       const state = regex.state;
       delete regex.state;
       let isIgnored = () => false;
       if (opts.ignore) {
         const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-        isIgnored = picomatch4(opts.ignore, ignoreOpts, returnState);
+        isIgnored = picomatch3(opts.ignore, ignoreOpts, returnState);
       }
       const matcher = (input2, returnObject = false) => {
-        const { isMatch, match, output: output2 } = picomatch4.test(input2, regex, options, { glob, posix });
+        const { isMatch, match, output: output2 } = picomatch3.test(input2, regex, options, { glob, posix });
         const result = { glob, state, regex, posix, input: input2, output: output2, match, isMatch };
         if (typeof opts.onResult === "function") {
           opts.onResult(result);
@@ -5800,7 +5800,7 @@ var require_picomatch = __commonJS({
       }
       return matcher;
     };
-    picomatch4.test = (input2, regex, options, { glob, posix } = {}) => {
+    picomatch3.test = (input2, regex, options, { glob, posix } = {}) => {
       if (typeof input2 !== "string") {
         throw new TypeError("Expected input to be a string");
       }
@@ -5817,24 +5817,24 @@ var require_picomatch = __commonJS({
       }
       if (match === false || opts.capture === true) {
         if (opts.matchBase === true || opts.basename === true) {
-          match = picomatch4.matchBase(input2, regex, options, posix);
+          match = picomatch3.matchBase(input2, regex, options, posix);
         } else {
           match = regex.exec(output2);
         }
       }
       return { isMatch: Boolean(match), match, output: output2 };
     };
-    picomatch4.matchBase = (input2, glob, options, posix = options && options.windows) => {
-      const regex = glob instanceof RegExp ? glob : picomatch4.makeRe(glob, options);
+    picomatch3.matchBase = (input2, glob, options, posix = options && options.windows) => {
+      const regex = glob instanceof RegExp ? glob : picomatch3.makeRe(glob, options);
       return regex.test(utils.basename(input2, { windows: posix }));
     };
-    picomatch4.isMatch = (str, patterns, options) => picomatch4(patterns, options)(str);
-    picomatch4.parse = (pattern, options) => {
-      if (Array.isArray(pattern)) return pattern.map((p) => picomatch4.parse(p, options));
+    picomatch3.isMatch = (str, patterns, options) => picomatch3(patterns, options)(str);
+    picomatch3.parse = (pattern, options) => {
+      if (Array.isArray(pattern)) return pattern.map((p) => picomatch3.parse(p, options));
       return parse3(pattern, { ...options, fastpaths: false });
     };
-    picomatch4.scan = (input2, options) => scan(input2, options);
-    picomatch4.compileRe = (state, options, returnOutput = false, returnState = false) => {
+    picomatch3.scan = (input2, options) => scan(input2, options);
+    picomatch3.compileRe = (state, options, returnOutput = false, returnState = false) => {
       if (returnOutput === true) {
         return state.output;
       }
@@ -5845,13 +5845,13 @@ var require_picomatch = __commonJS({
       if (state && state.negated === true) {
         source = `^(?!${source}).*$`;
       }
-      const regex = picomatch4.toRegex(source, options);
+      const regex = picomatch3.toRegex(source, options);
       if (returnState === true) {
         regex.state = state;
       }
       return regex;
     };
-    picomatch4.makeRe = (input2, options = {}, returnOutput = false, returnState = false) => {
+    picomatch3.makeRe = (input2, options = {}, returnOutput = false, returnState = false) => {
       if (!input2 || typeof input2 !== "string") {
         throw new TypeError("Expected a non-empty string");
       }
@@ -5862,9 +5862,9 @@ var require_picomatch = __commonJS({
       if (!parsed.output) {
         parsed = parse3(input2, options);
       }
-      return picomatch4.compileRe(parsed, options, returnOutput, returnState);
+      return picomatch3.compileRe(parsed, options, returnOutput, returnState);
     };
-    picomatch4.toRegex = (source, options) => {
+    picomatch3.toRegex = (source, options) => {
       try {
         const opts = options || {};
         return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
@@ -5873,8 +5873,8 @@ var require_picomatch = __commonJS({
         return /$^/;
       }
     };
-    picomatch4.constants = constants;
-    module2.exports = picomatch4;
+    picomatch3.constants = constants;
+    module2.exports = picomatch3;
   }
 });
 
@@ -5884,14 +5884,14 @@ var require_picomatch2 = __commonJS({
     "use strict";
     var pico = require_picomatch();
     var utils = require_utils();
-    function picomatch4(glob, options, returnState = false) {
+    function picomatch3(glob, options, returnState = false) {
       if (options && (options.windows === null || options.windows === void 0)) {
         options = { ...options, windows: utils.isWindows() };
       }
       return pico(glob, options, returnState);
     }
-    Object.assign(picomatch4, pico);
-    module2.exports = picomatch4;
+    Object.assign(picomatch3, pico);
+    module2.exports = picomatch3;
   }
 });
 
@@ -7542,9 +7542,9 @@ var require_util2 = __commonJS({
       return !headerCharRegex.test(characters);
     }
     var rangeHeaderRegex = /^bytes (\d+)-(\d+)\/(\d+)?$/;
-    function parseRangeHeader(range) {
-      if (range == null || range === "") return { start: 0, end: null, size: null };
-      const m2 = range ? range.match(rangeHeaderRegex) : null;
+    function parseRangeHeader(range2) {
+      if (range2 == null || range2 === "") return { start: 0, end: null, size: null };
+      const m2 = range2 ? range2.match(rangeHeaderRegex) : null;
       return m2 ? {
         start: parseInt(m2[1]),
         end: m2[2] ? parseInt(m2[2]) : null,
@@ -12608,7 +12608,7 @@ var require_client_h1 = __commonJS({
     var TIMEOUT_HEADERS = 2 | USE_FAST_TIMER;
     var TIMEOUT_BODY = 4 | USE_FAST_TIMER;
     var TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER;
-    var Parser = class {
+    var Parser2 = class {
       /**
          * @param {import('./client.js')} client
          * @param {import('net').Socket} socket
@@ -13088,7 +13088,7 @@ var require_client_h1 = __commonJS({
       socket[kIdleSocketValidation] = 0;
       socket[kIdleSocketValidationTimeout] = null;
       socket[kSocketUsed] = false;
-      socket[kParser] = new Parser(client, socket, llhttpInstance);
+      socket[kParser] = new Parser2(client, socket, llhttpInstance);
       util.addListener(socket, "error", onHttpSocketError);
       util.addListener(socket, "readable", onHttpSocketReadable);
       util.addListener(socket, "end", onHttpSocketEnd);
@@ -16832,16 +16832,16 @@ var require_retry_handler = __commonJS({
       const retryTime = new Date(retryAfter).getTime();
       return isNaN(retryTime) ? 0 : retryTime - Date.now();
     }
-    function validatePartialResponseContentLength(headers, range, statusCode, retryCount) {
+    function validatePartialResponseContentLength(headers, range2, statusCode, retryCount) {
       const contentLength = headers["content-length"];
       if (contentLength == null) {
         return;
       }
-      if (!Number.isFinite(range.start) || !Number.isFinite(range.end)) {
+      if (!Number.isFinite(range2.start) || !Number.isFinite(range2.end)) {
         return;
       }
       const length = Number(contentLength);
-      const expectedLength = range.end - range.start + 1;
+      const expectedLength = range2.end - range2.start + 1;
       if (!Number.isFinite(length) || length !== expectedLength) {
         throw new RequestRetryError("Content-Length mismatch", statusCode, {
           headers,
@@ -17051,8 +17051,8 @@ var require_retry_handler = __commonJS({
         }
         if (this.end == null) {
           if (statusCode === 206) {
-            const range = parseRangeHeader(headers["content-range"]);
-            if (range == null) {
+            const range2 = parseRangeHeader(headers["content-range"]);
+            if (range2 == null) {
               this.headersSent = true;
               this.handler.onResponseStart?.(
                 controller,
@@ -17062,8 +17062,8 @@ var require_retry_handler = __commonJS({
               );
               return;
             }
-            validatePartialResponseContentLength(headers, range, statusCode, this.retryCount);
-            const { start, size, end = size ? size - 1 : null } = range;
+            validatePartialResponseContentLength(headers, range2, statusCode, this.retryCount);
+            const { start, size, end = size ? size - 1 : null } = range2;
             assert2(
               start != null && Number.isFinite(start),
               "content-range mismatch"
@@ -35899,8 +35899,8 @@ function cleanRegex(source) {
   const end = source.endsWith("$") ? source.length - 1 : source.length;
   return source.slice(start, end);
 }
-function floatSafeRemainder(val, step) {
-  const ratio = val / step;
+function floatSafeRemainder(val, step2) {
+  const ratio = val / step2;
   const roundedRatio = Math.round(ratio);
   const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
   if (Math.abs(ratio - roundedRatio) < tolerance)
@@ -55148,6 +55148,1839 @@ var import_node_path5 = __toESM(require("node:path"), 1);
 
 // src/config/schema.ts
 var import_node_path4 = __toESM(require("node:path"), 1);
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/complex.js
+var complexFromPolar = (magnitude, phase, unit) => ({
+  kind: "complex",
+  re: magnitude * Math.cos(phase),
+  im: magnitude * Math.sin(phase),
+  unit
+});
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/computed-value.js
+var UnitSchema = external_exports.record(external_exports.string(), external_exports.number());
+var DurationUnitSchema = external_exports.enum([
+  "ms",
+  "s",
+  "min",
+  "h",
+  "d"
+]);
+var ComputedValueSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    kind: external_exports.literal("number"),
+    value: external_exports.number(),
+    unit: UnitSchema.optional()
+  }),
+  external_exports.object({
+    kind: external_exports.literal("text"),
+    value: external_exports.string()
+  }),
+  external_exports.object({
+    kind: external_exports.literal("boolean"),
+    value: external_exports.boolean()
+  }),
+  external_exports.object({
+    kind: external_exports.literal("instant"),
+    value: external_exports.string()
+  }),
+  external_exports.object({
+    kind: external_exports.literal("duration"),
+    value: external_exports.number(),
+    unit: DurationUnitSchema
+  }),
+  external_exports.object({
+    kind: external_exports.literal("complex"),
+    re: external_exports.number(),
+    im: external_exports.number(),
+    unit: UnitSchema.optional()
+  })
+]);
+function normalizeUnit(unit) {
+  if (unit === void 0) return {};
+  const normalized = {};
+  for (const [dimension, exponent] of Object.entries(unit)) if (exponent !== 0) normalized[dimension] = exponent;
+  return normalized;
+}
+function unitsEqual(a2, b) {
+  const normalizedA = normalizeUnit(a2);
+  const normalizedB = normalizeUnit(b);
+  const dimensionsA = Object.keys(normalizedA);
+  const dimensionsB = Object.keys(normalizedB);
+  if (dimensionsA.length !== dimensionsB.length) return false;
+  return dimensionsA.every((dimension) => normalizedA[dimension] === normalizedB[dimension]);
+}
+function combineUnitsForMultiply(a2, b) {
+  const normalizedA = normalizeUnit(a2);
+  const normalizedB = normalizeUnit(b);
+  const combined = { ...normalizedA };
+  for (const [dimension, exponent] of Object.entries(normalizedB)) combined[dimension] = (combined[dimension] ?? 0) + exponent;
+  return normalizeUnit(combined);
+}
+function combineUnitsForDivide(a2, b) {
+  const normalizedA = normalizeUnit(a2);
+  const normalizedB = normalizeUnit(b);
+  const combined = { ...normalizedA };
+  for (const [dimension, exponent] of Object.entries(normalizedB)) combined[dimension] = (combined[dimension] ?? 0) - exponent;
+  return normalizeUnit(combined);
+}
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/evaluation.js
+var IndeterminateReasonSchema = external_exports.object({
+  /** Which of the three reason categories applies. */
+  code: external_exports.enum([
+    "not-found",
+    "wrong-type",
+    "domain-error"
+  ]),
+  /** A human-readable explanation, for logging and debugging. */
+  message: external_exports.string()
+});
+function definite(value2) {
+  return {
+    status: "definite",
+    value: value2
+  };
+}
+function indeterminate(code, message) {
+  return {
+    status: "indeterminate",
+    reason: {
+      code,
+      message
+    }
+  };
+}
+function firstIndeterminate(...results) {
+  for (const result of results) if (result?.status === "indeterminate") return result.reason;
+}
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/json-value.js
+var JsonValueSchema = external_exports.lazy(() => external_exports.union([
+  external_exports.string(),
+  external_exports.number(),
+  external_exports.boolean(),
+  external_exports.null(),
+  external_exports.array(JsonValueSchema),
+  external_exports.record(external_exports.string(), JsonValueSchema)
+]));
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/tree.js
+var ComparisonOperatorSchema = external_exports.enum([
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "eq",
+  "neq"
+]);
+var TextComparisonOperatorSchema = external_exports.enum([
+  "equals",
+  "notEquals",
+  "matches",
+  "notMatches",
+  "portableMatches",
+  "portableNotMatches"
+]);
+var MembershipOperatorSchema = external_exports.enum(["in", "notIn"]);
+var ArithmeticOperatorSchema = external_exports.enum([
+  "add",
+  "subtract",
+  "multiply",
+  "divide",
+  "power",
+  "modulo"
+]);
+var HitPolicySchema = external_exports.enum(["first", "unique"]);
+var NotNodeSchema = external_exports.object({
+  kind: external_exports.literal("not"),
+  get operand() {
+    return PredicateNodeSchema;
+  }
+});
+var AndNodeSchema = external_exports.object({
+  kind: external_exports.literal("and"),
+  get left() {
+    return PredicateNodeSchema;
+  },
+  get right() {
+    return PredicateNodeSchema;
+  }
+});
+var OrNodeSchema = external_exports.object({
+  kind: external_exports.literal("or"),
+  get left() {
+    return PredicateNodeSchema;
+  },
+  get right() {
+    return PredicateNodeSchema;
+  }
+});
+var AllOfNodeSchema = external_exports.object({
+  kind: external_exports.literal("allOf"),
+  get operands() {
+    return external_exports.array(PredicateNodeSchema);
+  }
+});
+var AnyOfNodeSchema = external_exports.object({
+  kind: external_exports.literal("anyOf"),
+  get operands() {
+    return external_exports.array(PredicateNodeSchema);
+  }
+});
+var CompareNodeSchema = external_exports.object({
+  kind: external_exports.literal("compare"),
+  op: ComparisonOperatorSchema,
+  get left() {
+    return ExpressionNodeSchema;
+  },
+  get right() {
+    return ExpressionNodeSchema;
+  }
+});
+var TextCompareNodeSchema = external_exports.object({
+  kind: external_exports.literal("textCompare"),
+  op: TextComparisonOperatorSchema,
+  get left() {
+    return ExpressionNodeSchema;
+  },
+  get right() {
+    return ExpressionNodeSchema;
+  }
+});
+var MemberOfNodeSchema = external_exports.object({
+  kind: external_exports.literal("memberOf"),
+  op: MembershipOperatorSchema,
+  get operand() {
+    return ExpressionNodeSchema;
+  },
+  get candidates() {
+    return external_exports.array(ExpressionNodeSchema);
+  }
+});
+var ExistsNodeSchema = external_exports.object({
+  kind: external_exports.literal("exists"),
+  get operand() {
+    return ExpressionNodeSchema;
+  }
+});
+var SomeNodeSchema = external_exports.object({
+  kind: external_exports.literal("some"),
+  collection: JsonValueSchema,
+  get item() {
+    return PredicateNodeSchema;
+  },
+  get filter() {
+    return PredicateNodeSchema.optional();
+  }
+});
+var EveryNodeSchema = external_exports.object({
+  kind: external_exports.literal("every"),
+  collection: JsonValueSchema,
+  get item() {
+    return PredicateNodeSchema;
+  },
+  get filter() {
+    return PredicateNodeSchema.optional();
+  }
+});
+var TreeReferenceNodeSchema = external_exports.object({
+  kind: external_exports.literal("treeReference"),
+  key: JsonValueSchema
+});
+var PredicateNodeSchema = external_exports.discriminatedUnion("kind", [
+  NotNodeSchema,
+  AndNodeSchema,
+  OrNodeSchema,
+  AllOfNodeSchema,
+  AnyOfNodeSchema,
+  CompareNodeSchema,
+  TextCompareNodeSchema,
+  MemberOfNodeSchema,
+  ExistsNodeSchema,
+  SomeNodeSchema,
+  EveryNodeSchema,
+  TreeReferenceNodeSchema
+]);
+var NumberLiteralNodeSchema = external_exports.object({
+  kind: external_exports.literal("numberLiteral"),
+  value: external_exports.number(),
+  unit: UnitSchema.optional()
+});
+var TextLiteralNodeSchema = external_exports.object({
+  kind: external_exports.literal("textLiteral"),
+  value: external_exports.string()
+});
+var BooleanLiteralNodeSchema = external_exports.object({
+  kind: external_exports.literal("booleanLiteral"),
+  value: external_exports.boolean()
+});
+var InstantLiteralNodeSchema = external_exports.object({
+  kind: external_exports.literal("instantLiteral"),
+  /** ISO-8601 timestamp. */
+  value: external_exports.string()
+});
+var DurationLiteralNodeSchema = external_exports.object({
+  kind: external_exports.literal("durationLiteral"),
+  value: external_exports.number(),
+  unit: DurationUnitSchema
+});
+var ComplexRectangularLiteralNodeSchema = external_exports.strictObject({
+  kind: external_exports.literal("complexLiteral"),
+  re: external_exports.number(),
+  im: external_exports.number(),
+  unit: UnitSchema.optional()
+});
+var ComplexPolarLiteralNodeSchema = external_exports.strictObject({
+  kind: external_exports.literal("complexLiteral"),
+  magnitude: external_exports.number(),
+  phase: external_exports.number(),
+  unit: UnitSchema.optional()
+});
+var ComplexLiteralNodeSchema = external_exports.union([ComplexRectangularLiteralNodeSchema, ComplexPolarLiteralNodeSchema]);
+var ReferenceNodeSchema = external_exports.object({
+  kind: external_exports.literal("reference"),
+  key: JsonValueSchema,
+  unit: UnitSchema.optional()
+});
+var ArithmeticNodeSchema = external_exports.object({
+  kind: external_exports.literal("arithmetic"),
+  op: ArithmeticOperatorSchema,
+  get left() {
+    return ExpressionNodeSchema;
+  },
+  get right() {
+    return ExpressionNodeSchema;
+  }
+});
+var NegateNodeSchema = external_exports.object({
+  kind: external_exports.literal("negate"),
+  get operand() {
+    return ExpressionNodeSchema;
+  }
+});
+var CallNodeSchema = external_exports.object({
+  kind: external_exports.literal("call"),
+  fn: external_exports.string(),
+  get args() {
+    return external_exports.array(ExpressionNodeSchema);
+  }
+});
+var LookupNodeSchema = external_exports.object({
+  kind: external_exports.literal("lookup"),
+  table: JsonValueSchema,
+  get keys() {
+    return external_exports.array(ExpressionNodeSchema);
+  }
+});
+var ConditionalCaseSchema = external_exports.object({
+  get when() {
+    return PredicateNodeSchema;
+  },
+  get then() {
+    return ExpressionNodeSchema;
+  }
+});
+var ConditionalNodeSchema = external_exports.object({
+  kind: external_exports.literal("conditional"),
+  /** Absent means `"first"` -- the exact, unchanged behaviour of every tree serialised before this field existed. A deliberate, meaningful default, not a masked-bug fallback; see the `conditional` section of README.md for `"unique"`'s own absorption rules. */
+  hitPolicy: HitPolicySchema.optional(),
+  get cases() {
+    return external_exports.array(ConditionalCaseSchema);
+  },
+  get fallback() {
+    return ExpressionNodeSchema;
+  }
+});
+var FoldCombinerSchema = external_exports.discriminatedUnion("mode", [
+  external_exports.object({
+    mode: external_exports.literal("max"),
+    get item() {
+      return ExpressionNodeSchema;
+    }
+  }),
+  external_exports.object({
+    mode: external_exports.literal("min"),
+    get item() {
+      return ExpressionNodeSchema;
+    }
+  }),
+  external_exports.object({
+    mode: external_exports.literal("reduce"),
+    get initial() {
+      return ExpressionNodeSchema;
+    },
+    get combine() {
+      return ExpressionNodeSchema;
+    }
+  })
+]);
+var FoldNodeSchema = external_exports.object({
+  kind: external_exports.literal("fold"),
+  collection: JsonValueSchema,
+  get filter() {
+    return PredicateNodeSchema.optional();
+  },
+  combiner: FoldCombinerSchema
+});
+var AccumulatorNodeSchema = external_exports.object({ kind: external_exports.literal("accumulator") });
+var DelegateNodeSchema = external_exports.object({
+  kind: external_exports.literal("delegate"),
+  system: external_exports.string(),
+  payload: JsonValueSchema
+});
+var CoreExpressionNodeSchema = external_exports.discriminatedUnion("kind", [
+  NumberLiteralNodeSchema,
+  TextLiteralNodeSchema,
+  BooleanLiteralNodeSchema,
+  InstantLiteralNodeSchema,
+  DurationLiteralNodeSchema,
+  ReferenceNodeSchema,
+  ArithmeticNodeSchema,
+  NegateNodeSchema,
+  CallNodeSchema,
+  LookupNodeSchema,
+  ConditionalNodeSchema,
+  FoldNodeSchema,
+  AccumulatorNodeSchema,
+  DelegateNodeSchema,
+  TreeReferenceNodeSchema
+]);
+var ExpressionNodeSchema = external_exports.union([CoreExpressionNodeSchema, ComplexLiteralNodeSchema]);
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/functions.js
+var emptyFunctionRegistry = {};
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/evaluator-budget.js
+var DEFAULT_MAX_EVALUATION_NODES = 1e4;
+function createEvaluationBudget(maxNodes, maxNestingDepth) {
+  let nodesVisited = 0;
+  return { checkNode(nestingDepth) {
+    nodesVisited += 1;
+    if (nodesVisited > maxNodes) return indeterminate("domain-error", `evaluation exceeded the maximum of ${maxNodes.toString()} nodes visited in a single call (resource exhausted)`);
+    if (nestingDepth >= maxNestingDepth) return indeterminate("domain-error", `evaluation nesting depth exceeds the maximum of ${maxNestingDepth.toString()} (resource exhausted)`);
+  } };
+}
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/evaluator-effect.js
+function* wait(value2) {
+  return yield {
+    kind: "wait",
+    value: value2
+  };
+}
+function* all(tasks) {
+  return yield {
+    kind: "all",
+    tasks
+  };
+}
+function isThenable(value2) {
+  return typeof value2 === "object" && value2 !== null && "then" in value2 && typeof value2.then === "function";
+}
+async function runAsync(task) {
+  let step2 = task.next();
+  while (step2.done !== true) {
+    const suspension = step2.value;
+    const result = suspension.kind === "wait" ? await suspension.value : await Promise.all(suspension.tasks.map(runAsync));
+    step2 = task.next(result);
+  }
+  return step2.value;
+}
+function runSync(task) {
+  let step2 = task.next();
+  while (step2.done !== true) {
+    const suspension = step2.value;
+    let result;
+    if (suspension.kind === "wait") {
+      if (isThenable(suspension.value)) throw new TypeError("a resolver supplied to a synchronous evaluator returned a promise; use the asynchronous evaluator for asynchronous resolvers");
+      result = suspension.value;
+    } else result = suspension.tasks.map(runSync);
+    step2 = task.next(result);
+  }
+  return step2.value;
+}
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/evaluator-collection.js
+function* resolveParticipatingItems(evaluatePredicate2, collection, filter, context, resolvers, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth) {
+  const candidates = yield* wait(resolvers.resolveCollection(collection, context));
+  return yield* all(candidates.map(function* (item) {
+    if (filter === void 0) return {
+      item,
+      filterOutcome: "include"
+    };
+    const filterResult = yield* evaluatePredicate2(filter, item, resolvers, void 0, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+    if (filterResult.status === "indeterminate") return {
+      item,
+      filterOutcome: filterResult
+    };
+    return {
+      item,
+      filterOutcome: filterResult.value ? "include" : "exclude"
+    };
+  }));
+}
+function firstFilterIndeterminate(participating) {
+  for (const { filterOutcome } of participating) {
+    if (filterOutcome === "include" || filterOutcome === "exclude") continue;
+    if (filterOutcome.status === "indeterminate") return filterOutcome.reason;
+  }
+}
+
+// node_modules/.pnpm/trilean-regex@1.0.3/node_modules/trilean-regex/dist/ast.js
+function rangeContains(range2, unit) {
+  return unit >= range2.from && unit <= range2.to;
+}
+function charClassMatches(node2, unit) {
+  const inRanges = node2.ranges.some((range2) => rangeContains(range2, unit));
+  return node2.negated ? !inRanges : inRanges;
+}
+
+// node_modules/.pnpm/trilean-regex@1.0.3/node_modules/trilean-regex/dist/errors.js
+var RegexParseError = class extends Error {
+  pattern;
+  index;
+  constructor(pattern, index, reason) {
+    super(`invalid pattern at index ${String(index)}: ${reason}
+  ${pattern}
+  ${" ".repeat(index)}^`);
+    this.name = "RegexParseError";
+    this.pattern = pattern;
+    this.index = index;
+  }
+};
+
+// node_modules/.pnpm/trilean-regex@1.0.3/node_modules/trilean-regex/dist/shorthand-classes.js
+function codeOf(char) {
+  return char.charCodeAt(0);
+}
+function range(fromChar, toChar) {
+  return {
+    from: codeOf(fromChar),
+    to: codeOf(toChar)
+  };
+}
+function single(char) {
+  const codeUnit = codeOf(char);
+  return {
+    from: codeUnit,
+    to: codeUnit
+  };
+}
+var DIGIT_RANGES = [range("0", "9")];
+var WORD_RANGES = [
+  range("A", "Z"),
+  range("a", "z"),
+  range("0", "9"),
+  single("_")
+];
+var SPACE_RANGES = [
+  single(" "),
+  single("	"),
+  single("\n"),
+  single("\r"),
+  single("\f"),
+  single("\v")
+];
+function expandShorthandClass(letter) {
+  switch (letter) {
+    case "d":
+      return {
+        kind: "charClass",
+        negated: false,
+        ranges: DIGIT_RANGES
+      };
+    case "D":
+      return {
+        kind: "charClass",
+        negated: true,
+        ranges: DIGIT_RANGES
+      };
+    case "w":
+      return {
+        kind: "charClass",
+        negated: false,
+        ranges: WORD_RANGES
+      };
+    case "W":
+      return {
+        kind: "charClass",
+        negated: true,
+        ranges: WORD_RANGES
+      };
+    case "s":
+      return {
+        kind: "charClass",
+        negated: false,
+        ranges: SPACE_RANGES
+      };
+    case "S":
+      return {
+        kind: "charClass",
+        negated: true,
+        ranges: SPACE_RANGES
+      };
+    default:
+      throw new Error("unreachable shorthand class letter");
+  }
+}
+
+// node_modules/.pnpm/trilean-regex@1.0.3/node_modules/trilean-regex/dist/parser.js
+var SEQUENCE_TERMINATORS = /* @__PURE__ */ new Set(["|", ")"]);
+var SIMPLE_ESCAPES = {
+  ".": ".",
+  "*": "*",
+  "+": "+",
+  "?": "?",
+  "(": "(",
+  ")": ")",
+  "[": "[",
+  "]": "]",
+  "{": "{",
+  "}": "}",
+  "|": "|",
+  "^": "^",
+  $: "$",
+  "\\": "\\",
+  "/": "/",
+  n: "\n",
+  t: "	",
+  r: "\r",
+  f: "\f",
+  v: "\v"
+};
+var Parser = class {
+  pattern;
+  pos = 0;
+  constructor(pattern) {
+    this.pattern = pattern;
+  }
+  get position() {
+    return this.pos;
+  }
+  atEnd() {
+    return this.pos >= this.pattern.length;
+  }
+  peek(offset = 0) {
+    return this.pattern[this.pos + offset];
+  }
+  advance() {
+    const char = this.pattern[this.pos];
+    if (char === void 0) throw new RegexParseError(this.pattern, this.pos, "unexpected end of pattern");
+    this.pos += 1;
+    return char;
+  }
+  parseAlternation() {
+    const firstBranch = this.parseSequence();
+    const laterBranches = [];
+    while (this.peek() === "|") {
+      this.advance();
+      laterBranches.push(this.parseSequence());
+    }
+    return laterBranches.length === 0 ? firstBranch : {
+      kind: "alternation",
+      branches: [firstBranch, ...laterBranches]
+    };
+  }
+  parseSequence() {
+    if (this.atEnd() || SEQUENCE_TERMINATORS.has(this.peek() ?? "")) return {
+      kind: "concat",
+      operands: []
+    };
+    const firstOperand = this.parseQuantified();
+    const laterOperands = [];
+    while (!this.atEnd() && !SEQUENCE_TERMINATORS.has(this.peek() ?? "")) laterOperands.push(this.parseQuantified());
+    return laterOperands.length === 0 ? firstOperand : {
+      kind: "concat",
+      operands: [firstOperand, ...laterOperands]
+    };
+  }
+  parseQuantified() {
+    const atomStart = this.pos;
+    const atom = this.parseAtom();
+    if (atom.kind === "anchorStart" || atom.kind === "anchorEnd") {
+      if (this.peekIsQuantifierStart()) throw new RegexParseError(this.pattern, atomStart, `an anchor ('${atom.kind === "anchorStart" ? "^" : "$"}') cannot be quantified`);
+      return atom;
+    }
+    const quantifier = this.tryParseQuantifier();
+    if (quantifier === void 0) return atom;
+    if (this.peekIsQuantifierStart()) throw new RegexParseError(this.pattern, this.pos, "a quantifier cannot itself be quantified -- this grammar has no lazy or possessive modifiers, since a pattern that only ever answers a yes/no match question has no notion for either to change");
+    switch (quantifier.kind) {
+      case "star":
+        return {
+          kind: "star",
+          operand: atom
+        };
+      case "plus":
+        return {
+          kind: "plus",
+          operand: atom
+        };
+      case "optional":
+        return {
+          kind: "optional",
+          operand: atom
+        };
+      case "repeat":
+        return {
+          kind: "repeat",
+          operand: atom,
+          min: quantifier.min,
+          max: quantifier.max
+        };
+      default:
+        throw new Error("unreachable quantifier kind");
+    }
+  }
+  /** A pure lookahead: restores `pos` before returning in every case, including through `tryParseBound`'s own successful parse. Used only to decide whether a second quantifier immediately follows the one just applied, which is always a parse error (see `parseQuantified`). */
+  peekIsQuantifierStart() {
+    const c2 = this.peek();
+    if (c2 === "*" || c2 === "+" || c2 === "?") return true;
+    if (c2 === "{") {
+      const savedPos = this.pos;
+      const bound = this.tryParseBound();
+      this.pos = savedPos;
+      return bound !== void 0;
+    }
+    return false;
+  }
+  tryParseQuantifier() {
+    const c2 = this.peek();
+    if (c2 === "*") {
+      this.advance();
+      return { kind: "star" };
+    }
+    if (c2 === "+") {
+      this.advance();
+      return { kind: "plus" };
+    }
+    if (c2 === "?") {
+      this.advance();
+      return { kind: "optional" };
+    }
+    if (c2 === "{") {
+      const bound = this.tryParseBound();
+      if (bound === void 0) return void 0;
+      return {
+        kind: "repeat",
+        min: bound.min,
+        max: bound.max
+      };
+    }
+  }
+  /**
+  * Attempts `{min}` / `{min,}` / `{min,max}` starting at the current `{`. Rewinds and returns `undefined` for anything that is not exactly one of those three shapes -- including `{}`, `{,5}`, and a `{` with no closing brace at all -- so that an unrecognised `{` falls back to being parsed as a literal character by the caller, matching how a bounded-repetition quantifier is conventionally the only special meaning `{` ever carries.
+  *
+  * A backwards bound (`{5,2}`) is a real error rather than a fallback-to-literal case: the syntax is unambiguously a quantifier attempt, so this throws instead of returning `undefined` for it.
+  */
+  tryParseBound() {
+    const savedPos = this.pos;
+    this.pos += 1;
+    const minDigits = this.readDigits();
+    if (minDigits === "") {
+      this.pos = savedPos;
+      return;
+    }
+    let maxDigits;
+    let hasComma = false;
+    if (this.peek() === ",") {
+      hasComma = true;
+      this.pos += 1;
+      maxDigits = this.readDigits();
+    }
+    if (this.peek() !== "}") {
+      this.pos = savedPos;
+      return;
+    }
+    this.pos += 1;
+    const min = Number.parseInt(minDigits, 10);
+    const max = !hasComma ? min : maxDigits === "" ? void 0 : Number.parseInt(maxDigits ?? "", 10);
+    if (max !== void 0 && max < min) throw new RegexParseError(this.pattern, savedPos, `quantifier range is backwards: {${minDigits}${hasComma ? "," + (maxDigits ?? "") : ""}} would require between ${String(min)} and ${String(max)} repetitions`);
+    return {
+      min,
+      max
+    };
+  }
+  readDigits() {
+    let digits = "";
+    for (; ; ) {
+      const c2 = this.peek();
+      if (c2 === void 0 || c2 < "0" || c2 > "9") break;
+      digits += c2;
+      this.pos += 1;
+    }
+    return digits;
+  }
+  parseAtom() {
+    const c2 = this.peek();
+    if (c2 === void 0) throw new RegexParseError(this.pattern, this.pos, "unexpected end of pattern");
+    if (c2 === "^") {
+      this.advance();
+      return { kind: "anchorStart" };
+    }
+    if (c2 === "$") {
+      this.advance();
+      return { kind: "anchorEnd" };
+    }
+    if (c2 === ".") {
+      this.advance();
+      return { kind: "anyChar" };
+    }
+    if (c2 === "(") return this.parseGroup();
+    if (c2 === "[") return this.parseCharClass();
+    if (c2 === "\\") return this.parseEscapedAtom();
+    if (c2 === "*" || c2 === "+" || c2 === "?") throw new RegexParseError(this.pattern, this.pos, `quantifier '${c2}' with nothing to repeat`);
+    this.advance();
+    return {
+      kind: "literal",
+      codeUnit: c2.charCodeAt(0)
+    };
+  }
+  parseGroup() {
+    const start = this.pos;
+    this.advance();
+    if (this.peek() === "?" && this.peek(1) === ":") {
+      this.advance();
+      this.advance();
+    } else throw new RegexParseError(this.pattern, start, "capturing groups are not supported in this grammar -- there is nothing to capture, since a pattern only ever answers whether it matches. Use '(?:...)' for grouping.");
+    const inner = this.parseAlternation();
+    if (this.peek() !== ")") throw new RegexParseError(this.pattern, this.pos, "expected ')' to close '(?:'");
+    this.advance();
+    return inner;
+  }
+  parseEscapedAtom() {
+    const backslashPos = this.pos;
+    this.advance();
+    if (this.atEnd()) throw new RegexParseError(this.pattern, backslashPos, "trailing backslash with nothing to escape");
+    const c2 = this.advance();
+    if (c2 === "d" || c2 === "D" || c2 === "w" || c2 === "W" || c2 === "s" || c2 === "S") return expandShorthandClass(c2);
+    const literal2 = SIMPLE_ESCAPES[c2];
+    if (literal2 !== void 0) return {
+      kind: "literal",
+      codeUnit: literal2.charCodeAt(0)
+    };
+    throw new RegexParseError(this.pattern, backslashPos, `unknown escape sequence '\\${c2}'`);
+  }
+  parseCharClass() {
+    const start = this.pos;
+    this.advance();
+    let negated = false;
+    if (this.peek() === "^") {
+      this.advance();
+      negated = true;
+    }
+    const ranges = [];
+    for (; ; ) {
+      if (this.atEnd()) throw new RegexParseError(this.pattern, start, "unterminated character class -- missing closing ']'");
+      if (this.peek() === "]") {
+        if (ranges.length === 0) throw new RegexParseError(this.pattern, this.pos, "a character class must contain at least one item -- ']' immediately, or immediately after '[^', is not the empty class here (escape it as '\\]' to match a literal ']')");
+        this.advance();
+        break;
+      }
+      ranges.push(...this.parseClassItem());
+    }
+    return {
+      kind: "charClass",
+      negated,
+      ranges
+    };
+  }
+  parseClassItem() {
+    const c2 = this.peek();
+    if (c2 === "\\") {
+      const backslashPos = this.pos;
+      this.advance();
+      if (this.atEnd()) throw new RegexParseError(this.pattern, backslashPos, "trailing backslash with nothing to escape");
+      const escaped = this.advance();
+      if (escaped === "d" || escaped === "w" || escaped === "s") return expandShorthandClass(escaped).ranges;
+      if (escaped === "D" || escaped === "W" || escaped === "S") throw new RegexParseError(this.pattern, backslashPos, `the negated shorthand class '\\${escaped}' cannot be embedded inside a character class, because its complement cannot be represented as a set of ranges to union with the class's other members -- use it as its own atom instead of embedding it here`);
+      const literal2 = SIMPLE_ESCAPES[escaped];
+      if (literal2 === void 0) throw new RegexParseError(this.pattern, backslashPos, `unknown escape sequence '\\${escaped}'`);
+      return this.parseOptionalRangeFrom(literal2.charCodeAt(0));
+    }
+    if (c2 === void 0) throw new RegexParseError(this.pattern, this.pos, "unterminated character class -- missing closing ']'");
+    this.advance();
+    return this.parseOptionalRangeFrom(c2.charCodeAt(0));
+  }
+  parseOptionalRangeFrom(fromCode) {
+    if (this.peek() === "-" && this.peek(1) !== void 0 && this.peek(1) !== "]") {
+      const hyphenPos = this.pos;
+      this.advance();
+      const toCode = this.parseClassRangeEndpoint();
+      if (toCode < fromCode) throw new RegexParseError(this.pattern, hyphenPos, `invalid range in character class: '${String.fromCharCode(fromCode)}-${String.fromCharCode(toCode)}' is reversed`);
+      return [{
+        from: fromCode,
+        to: toCode
+      }];
+    }
+    return [{
+      from: fromCode,
+      to: fromCode
+    }];
+  }
+  parseClassRangeEndpoint() {
+    const c2 = this.peek();
+    if (c2 === "\\") {
+      const backslashPos = this.pos;
+      this.advance();
+      if (this.atEnd()) throw new RegexParseError(this.pattern, backslashPos, "trailing backslash with nothing to escape");
+      const escaped = this.advance();
+      if (escaped === "d" || escaped === "D" || escaped === "w" || escaped === "W" || escaped === "s" || escaped === "S") throw new RegexParseError(this.pattern, backslashPos, `a shorthand class ('\\${escaped}') cannot be a range endpoint`);
+      const literal2 = SIMPLE_ESCAPES[escaped];
+      if (literal2 === void 0) throw new RegexParseError(this.pattern, backslashPos, `unknown escape sequence '\\${escaped}'`);
+      return literal2.charCodeAt(0);
+    }
+    if (c2 === void 0) throw new RegexParseError(this.pattern, this.pos, "unterminated character class -- missing closing ']'");
+    this.advance();
+    return c2.charCodeAt(0);
+  }
+};
+function parseRegex(pattern) {
+  const parser = new Parser(pattern);
+  const node2 = parser.parseAlternation();
+  if (!parser.atEnd()) throw new RegexParseError(pattern, parser.position, "unexpected character -- if this was meant literally, escape it with a backslash");
+  return node2;
+}
+
+// node_modules/.pnpm/trilean-regex@1.0.3/node_modules/trilean-regex/dist/nfa.js
+var NfaBuilder = class {
+  states = [];
+  add(state) {
+    this.states.push(state);
+    return this.states.length - 1;
+  }
+  patch(targets, target) {
+    for (const patchTarget of targets) {
+      const state = this.states[patchTarget.state];
+      if (state === void 0) continue;
+      switch (patchTarget.field) {
+        case "to":
+          if (state.kind === "char" || state.kind === "anchorStart" || state.kind === "anchorEnd") state.to = target;
+          break;
+        case "to1":
+          if (state.kind === "split") state.to1 = target;
+          break;
+        case "to2":
+          if (state.kind === "split") state.to2 = target;
+      }
+    }
+  }
+  /** A fragment that matches the empty string unconditionally: both of a split's own branches dangle straight out, so whichever target they are later patched to is reached having consumed nothing. Used for `{0}`/`{0,0}` repetition, the one shape bounded repetition can produce that no other node kind already covers. */
+  emptyFrag() {
+    const idx = this.add({
+      kind: "split",
+      to1: -1,
+      to2: -1
+    });
+    return {
+      start: idx,
+      out: [{
+        state: idx,
+        field: "to1"
+      }, {
+        state: idx,
+        field: "to2"
+      }]
+    };
+  }
+  compileRepeat(node2) {
+    const { operand, min, max } = node2;
+    if (max === void 0) {
+      if (min === 0) return this.compileNode({
+        kind: "star",
+        operand
+      });
+      const parts2 = [];
+      for (let i2 = 0; i2 < min - 1; i2 += 1) parts2.push(operand);
+      parts2.push({
+        kind: "plus",
+        operand
+      });
+      return this.compileNode({
+        kind: "concat",
+        operands: parts2
+      });
+    }
+    const parts = [];
+    for (let i2 = 0; i2 < min; i2 += 1) parts.push(operand);
+    for (let i2 = 0; i2 < max - min; i2 += 1) parts.push({
+      kind: "optional",
+      operand
+    });
+    if (parts.length === 0) return this.emptyFrag();
+    return this.compileNode({
+      kind: "concat",
+      operands: parts
+    });
+  }
+  compileNode(node2) {
+    switch (node2.kind) {
+      case "literal": {
+        const codeUnit = node2.codeUnit;
+        const idx = this.add({
+          kind: "char",
+          test: (unit) => unit === codeUnit,
+          to: -1
+        });
+        return {
+          start: idx,
+          out: [{
+            state: idx,
+            field: "to"
+          }]
+        };
+      }
+      case "anyChar": {
+        const idx = this.add({
+          kind: "char",
+          test: () => true,
+          to: -1
+        });
+        return {
+          start: idx,
+          out: [{
+            state: idx,
+            field: "to"
+          }]
+        };
+      }
+      case "charClass": {
+        const idx = this.add({
+          kind: "char",
+          test: (unit) => charClassMatches(node2, unit),
+          to: -1
+        });
+        return {
+          start: idx,
+          out: [{
+            state: idx,
+            field: "to"
+          }]
+        };
+      }
+      case "anchorStart": {
+        const idx = this.add({
+          kind: "anchorStart",
+          to: -1
+        });
+        return {
+          start: idx,
+          out: [{
+            state: idx,
+            field: "to"
+          }]
+        };
+      }
+      case "anchorEnd": {
+        const idx = this.add({
+          kind: "anchorEnd",
+          to: -1
+        });
+        return {
+          start: idx,
+          out: [{
+            state: idx,
+            field: "to"
+          }]
+        };
+      }
+      case "concat": {
+        if (node2.operands.length === 0) return this.emptyFrag();
+        const [first, ...rest] = node2.operands;
+        if (first === void 0) throw new Error("unreachable: a non-empty operands array always has a first element");
+        let frag = this.compileNode(first);
+        for (const operand of rest) {
+          const next = this.compileNode(operand);
+          this.patch(frag.out, next.start);
+          frag = {
+            start: frag.start,
+            out: next.out
+          };
+        }
+        return frag;
+      }
+      case "alternation": {
+        const [first, ...rest] = node2.branches;
+        if (first === void 0) throw new Error("unreachable: AlternationNode always has at least two branches");
+        let frag = this.compileNode(first);
+        for (const branch of rest) {
+          const next = this.compileNode(branch);
+          frag = {
+            start: this.add({
+              kind: "split",
+              to1: frag.start,
+              to2: next.start
+            }),
+            out: [...frag.out, ...next.out]
+          };
+        }
+        return frag;
+      }
+      case "star": {
+        const inner = this.compileNode(node2.operand);
+        const splitIdx = this.add({
+          kind: "split",
+          to1: inner.start,
+          to2: -1
+        });
+        this.patch(inner.out, splitIdx);
+        return {
+          start: splitIdx,
+          out: [{
+            state: splitIdx,
+            field: "to2"
+          }]
+        };
+      }
+      case "plus": {
+        const inner = this.compileNode(node2.operand);
+        const splitIdx = this.add({
+          kind: "split",
+          to1: inner.start,
+          to2: -1
+        });
+        this.patch(inner.out, splitIdx);
+        return {
+          start: inner.start,
+          out: [{
+            state: splitIdx,
+            field: "to2"
+          }]
+        };
+      }
+      case "optional": {
+        const inner = this.compileNode(node2.operand);
+        const splitIdx = this.add({
+          kind: "split",
+          to1: inner.start,
+          to2: -1
+        });
+        return {
+          start: splitIdx,
+          out: [...inner.out, {
+            state: splitIdx,
+            field: "to2"
+          }]
+        };
+      }
+      case "repeat":
+        return this.compileRepeat(node2);
+      default:
+        throw new Error("unreachable regex node kind");
+    }
+  }
+  build(root) {
+    const frag = this.compileNode(root);
+    const matchState = this.add({ kind: "match" });
+    this.patch(frag.out, matchState);
+    return {
+      states: this.states,
+      start: frag.start,
+      matchState
+    };
+  }
+};
+function compileToNfa(node2) {
+  return new NfaBuilder().build(node2);
+}
+
+// node_modules/.pnpm/trilean-regex@1.0.3/node_modules/trilean-regex/dist/matcher.js
+function closure(nfa, seeds, pos, length) {
+  const result = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [...seeds];
+  while (stack.length > 0) {
+    const idx = stack.pop();
+    if (idx === void 0) continue;
+    if (visited.has(idx)) continue;
+    visited.add(idx);
+    const state = nfa.states[idx];
+    if (state === void 0) continue;
+    switch (state.kind) {
+      case "char":
+      case "match":
+        result.add(idx);
+        break;
+      case "split":
+        stack.push(state.to1, state.to2);
+        break;
+      case "anchorStart":
+        if (pos === 0) stack.push(state.to);
+        break;
+      case "anchorEnd":
+        if (pos === length) stack.push(state.to);
+    }
+  }
+  return result;
+}
+function step(nfa, current, codeUnit) {
+  const next = /* @__PURE__ */ new Set();
+  for (const idx of current) {
+    const state = nfa.states[idx];
+    if (state?.kind !== "char") continue;
+    if (state.test(codeUnit)) next.add(state.to);
+  }
+  return next;
+}
+function matchesNfa(nfa, input2) {
+  const length = input2.length;
+  let current = closure(nfa, [nfa.start], 0, length);
+  if (current.has(nfa.matchState)) return true;
+  for (let pos = 0; pos < length; pos += 1) {
+    const codeUnit = input2.charCodeAt(pos);
+    const stepped = step(nfa, current, codeUnit);
+    stepped.add(nfa.start);
+    current = closure(nfa, [...stepped], pos + 1, length);
+    if (current.has(nfa.matchState)) return true;
+  }
+  return false;
+}
+function compilePattern(pattern) {
+  const nfa = compileToNfa(parseRegex(pattern));
+  return { test: (input2) => matchesNfa(nfa, input2) };
+}
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/evaluator-operations.js
+function combineAnd(left, right) {
+  if (left.status === "definite" && !left.value) return definite(false);
+  if (right.status === "definite" && !right.value) return definite(false);
+  const reason = firstIndeterminate(left, right);
+  if (reason !== void 0) return {
+    status: "indeterminate",
+    reason
+  };
+  return definite(true);
+}
+function combineOr(left, right) {
+  if (left.status === "definite" && left.value) return definite(true);
+  if (right.status === "definite" && right.value) return definite(true);
+  const reason = firstIndeterminate(left, right);
+  if (reason !== void 0) return {
+    status: "indeterminate",
+    reason
+  };
+  return definite(false);
+}
+function applyComparisonOperator(op, left, right) {
+  switch (op) {
+    case "gt":
+      return left > right;
+    case "gte":
+      return left >= right;
+    case "lt":
+      return left < right;
+    case "lte":
+      return left <= right;
+    case "eq":
+      return left === right;
+    case "neq":
+      return left !== right;
+    default:
+      throw new Error("unreachable comparison operator");
+  }
+}
+var millisecondsPerDurationUnit = {
+  ms: 1,
+  s: 1e3,
+  min: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function toMilliseconds(value2, unit) {
+  return value2 * millisecondsPerDurationUnit[unit];
+}
+function toEpochMilliseconds(value2) {
+  const epochMilliseconds = Date.parse(value2);
+  return Number.isNaN(epochMilliseconds) ? void 0 : epochMilliseconds;
+}
+function unparseableInstant(value2) {
+  return indeterminate("wrong-type", `'${value2}' is not a parseable ISO-8601 timestamp`);
+}
+function instantFromEpochMilliseconds(epochMilliseconds) {
+  const shifted = new Date(epochMilliseconds);
+  if (Number.isNaN(shifted.getTime())) return indeterminate("domain-error", "the resulting instant falls outside the representable timestamp range");
+  return definite({
+    kind: "instant",
+    value: shifted.toISOString()
+  });
+}
+function compareValues(op, left, right) {
+  switch (left.kind) {
+    case "number":
+      if (right.kind !== "number") return indeterminate("wrong-type", `cannot compare a 'number' value with a '${right.kind}' value`);
+      if (!unitsEqual(left.unit, right.unit)) return indeterminate("wrong-type", "cannot compare numbers with incompatible units");
+      return definite(applyComparisonOperator(op, left.value, right.value));
+    case "text":
+      return indeterminate("wrong-type", "text values are not comparable via 'compare'; use 'textCompare'");
+    case "boolean":
+      if (right.kind !== "boolean") return indeterminate("wrong-type", `cannot compare a 'boolean' value with a '${right.kind}' value`);
+      if (op !== "eq" && op !== "neq") return indeterminate("wrong-type", `booleans have no natural ordering; '${op}' is only defined for 'eq'/'neq'`);
+      return definite(op === "eq" ? left.value === right.value : left.value !== right.value);
+    case "instant": {
+      if (right.kind !== "instant") return indeterminate("wrong-type", `cannot compare an 'instant' value with a '${right.kind}' value`);
+      const leftEpoch = toEpochMilliseconds(left.value);
+      if (leftEpoch === void 0) return unparseableInstant(left.value);
+      const rightEpoch = toEpochMilliseconds(right.value);
+      if (rightEpoch === void 0) return unparseableInstant(right.value);
+      return definite(applyComparisonOperator(op, leftEpoch, rightEpoch));
+    }
+    case "duration":
+      if (right.kind !== "duration") return indeterminate("wrong-type", `cannot compare a 'duration' value with a '${right.kind}' value`);
+      return definite(applyComparisonOperator(op, toMilliseconds(left.value, left.unit), toMilliseconds(right.value, right.unit)));
+    case "complex":
+      if (op !== "eq" && op !== "neq") return indeterminate("wrong-type", `ordering operator '${op}' is not defined for complex values; the complex plane has no total order`);
+      if (right.kind !== "complex") return indeterminate("wrong-type", `cannot compare a 'complex' value with a '${right.kind}' value`);
+      if (!unitsEqual(left.unit, right.unit)) return indeterminate("wrong-type", "cannot compare complex values with incompatible units");
+      return definite(op === "eq" ? left.re === right.re && left.im === right.im : left.re !== right.re || left.im !== right.im);
+    default:
+      throw new Error("unreachable computed-value kind");
+  }
+}
+function compareText(op, left, right) {
+  if (left.kind !== "text") return indeterminate("wrong-type", `'textCompare' requires 'text' operands; the left operand is '${left.kind}'`);
+  if (right.kind !== "text") return indeterminate("wrong-type", `'textCompare' requires 'text' operands; the right operand is '${right.kind}'`);
+  switch (op) {
+    case "equals":
+      return definite(left.value === right.value);
+    case "notEquals":
+      return definite(left.value !== right.value);
+    case "matches":
+    case "notMatches": {
+      let pattern;
+      try {
+        pattern = new RegExp(right.value);
+      } catch {
+        return indeterminate("wrong-type", `'${right.value}' is not a valid regular expression pattern`);
+      }
+      const isMatch = pattern.test(left.value);
+      return definite(op === "matches" ? isMatch : !isMatch);
+    }
+    case "portableMatches":
+    case "portableNotMatches": {
+      let compiled;
+      try {
+        compiled = compilePattern(right.value);
+      } catch (error62) {
+        const reason = error62 instanceof RegexParseError ? error62.message : String(error62);
+        return indeterminate("wrong-type", `'${right.value}' is not a valid trilean-regex pattern: ${reason}`);
+      }
+      const isMatch = compiled.test(left.value);
+      return definite(op === "portableMatches" ? isMatch : !isMatch);
+    }
+    default:
+      throw new Error("unreachable text comparison operator");
+  }
+}
+function computeMembershipMatch(operand, candidate) {
+  switch (operand.kind) {
+    case "number":
+      if (candidate.kind !== "number") return indeterminate("wrong-type", `cannot compare a 'number' value with a '${candidate.kind}' value for membership`);
+      if (!unitsEqual(operand.unit, candidate.unit)) return indeterminate("wrong-type", "cannot compare numbers with incompatible units for membership");
+      return definite(operand.value === candidate.value);
+    case "text":
+      if (candidate.kind !== "text") return indeterminate("wrong-type", `cannot compare a 'text' value with a '${candidate.kind}' value for membership`);
+      return definite(operand.value === candidate.value);
+    case "boolean":
+      if (candidate.kind !== "boolean") return indeterminate("wrong-type", `cannot compare a 'boolean' value with a '${candidate.kind}' value for membership`);
+      return definite(operand.value === candidate.value);
+    case "instant": {
+      if (candidate.kind !== "instant") return indeterminate("wrong-type", `cannot compare an 'instant' value with a '${candidate.kind}' value for membership`);
+      const operandEpoch = toEpochMilliseconds(operand.value);
+      if (operandEpoch === void 0) return unparseableInstant(operand.value);
+      const candidateEpoch = toEpochMilliseconds(candidate.value);
+      if (candidateEpoch === void 0) return unparseableInstant(candidate.value);
+      return definite(operandEpoch === candidateEpoch);
+    }
+    case "duration":
+      if (candidate.kind !== "duration") return indeterminate("wrong-type", `cannot compare a 'duration' value with a '${candidate.kind}' value for membership`);
+      return definite(toMilliseconds(operand.value, operand.unit) === toMilliseconds(candidate.value, candidate.unit));
+    case "complex":
+      if (candidate.kind !== "complex") return indeterminate("wrong-type", `cannot compare a 'complex' value with a '${candidate.kind}' value for membership`);
+      if (!unitsEqual(operand.unit, candidate.unit)) return indeterminate("wrong-type", "cannot compare complex values with incompatible units for membership");
+      return definite(operand.re === candidate.re && operand.im === candidate.im);
+    default:
+      throw new Error("unreachable computed-value kind");
+  }
+}
+function isDimensionless(unit) {
+  return unitsEqual(unit, void 0);
+}
+function applyNegate(operand) {
+  switch (operand.kind) {
+    case "number":
+      return definite({
+        kind: "number",
+        value: -operand.value,
+        unit: operand.unit
+      });
+    case "duration":
+      return definite({
+        kind: "duration",
+        value: -operand.value,
+        unit: operand.unit
+      });
+    case "complex":
+      return definite({
+        kind: "complex",
+        re: -operand.re,
+        im: -operand.im,
+        unit: operand.unit
+      });
+    case "text":
+    case "instant":
+    case "boolean":
+      return indeterminate("wrong-type", `cannot negate a '${operand.kind}' value`);
+    default:
+      throw new Error("unreachable computed-value kind");
+  }
+}
+function applyArithmeticOnNumbers(op, left, right) {
+  switch (op) {
+    case "add":
+      if (!unitsEqual(left.unit, right.unit)) return indeterminate("wrong-type", "cannot add numbers with incompatible units");
+      return definite({
+        kind: "number",
+        value: left.value + right.value,
+        unit: left.unit
+      });
+    case "subtract":
+      if (!unitsEqual(left.unit, right.unit)) return indeterminate("wrong-type", "cannot subtract numbers with incompatible units");
+      return definite({
+        kind: "number",
+        value: left.value - right.value,
+        unit: left.unit
+      });
+    case "multiply":
+      return definite({
+        kind: "number",
+        value: left.value * right.value,
+        unit: combineUnitsForMultiply(left.unit, right.unit)
+      });
+    case "divide":
+      if (right.value === 0) return indeterminate("domain-error", "division by zero");
+      return definite({
+        kind: "number",
+        value: left.value / right.value,
+        unit: combineUnitsForDivide(left.unit, right.unit)
+      });
+    case "power":
+      if (!isDimensionless(left.unit) || !isDimensionless(right.unit)) return indeterminate("wrong-type", "'power' requires dimensionless operands");
+      if (left.value < 0 && !Number.isInteger(right.value)) return indeterminate("domain-error", "a negative base raised to a non-integer power is not a real number");
+      if (left.value === 0 && right.value < 0) return indeterminate("domain-error", "zero raised to a negative power is a division by zero");
+      return definite({
+        kind: "number",
+        value: left.value ** right.value
+      });
+    case "modulo":
+      if (!isDimensionless(left.unit) || !isDimensionless(right.unit)) return indeterminate("wrong-type", "'modulo' requires dimensionless operands");
+      if (right.value === 0) return indeterminate("domain-error", "modulo by zero");
+      return definite({
+        kind: "number",
+        value: left.value % right.value
+      });
+    default:
+      throw new Error("unreachable arithmetic operator");
+  }
+}
+function applyArithmeticOnDurations(op, left, right) {
+  switch (op) {
+    case "add":
+      return definite({
+        kind: "duration",
+        value: toMilliseconds(left.value, left.unit) + toMilliseconds(right.value, right.unit),
+        unit: "ms"
+      });
+    case "subtract":
+      return definite({
+        kind: "duration",
+        value: toMilliseconds(left.value, left.unit) - toMilliseconds(right.value, right.unit),
+        unit: "ms"
+      });
+    case "multiply":
+    case "divide":
+    case "power":
+    case "modulo":
+      return indeterminate("wrong-type", `arithmetic operator '${op}' is not defined between two 'duration' values`);
+    default:
+      throw new Error("unreachable arithmetic operator");
+  }
+}
+function toComplexValue(value2) {
+  if (value2.kind === "complex") return value2;
+  return {
+    kind: "complex",
+    re: value2.value,
+    im: 0,
+    unit: value2.unit
+  };
+}
+function multiplyComplexValues(left, right) {
+  return {
+    kind: "complex",
+    re: left.re * right.re - left.im * right.im,
+    im: left.re * right.im + left.im * right.re,
+    unit: combineUnitsForMultiply(left.unit, right.unit)
+  };
+}
+function applyArithmeticOnComplex(op, left, right) {
+  switch (op) {
+    case "add":
+      if (!unitsEqual(left.unit, right.unit)) return indeterminate("wrong-type", "cannot add complex values with incompatible units");
+      return definite({
+        kind: "complex",
+        re: left.re + right.re,
+        im: left.im + right.im,
+        unit: left.unit
+      });
+    case "subtract":
+      if (!unitsEqual(left.unit, right.unit)) return indeterminate("wrong-type", "cannot subtract complex values with incompatible units");
+      return definite({
+        kind: "complex",
+        re: left.re - right.re,
+        im: left.im - right.im,
+        unit: left.unit
+      });
+    case "multiply":
+      return definite(multiplyComplexValues(left, right));
+    case "divide": {
+      const divisorSquaredMagnitude = right.re * right.re + right.im * right.im;
+      if (divisorSquaredMagnitude === 0) return indeterminate("domain-error", "division by zero");
+      return definite({
+        kind: "complex",
+        re: (left.re * right.re + left.im * right.im) / divisorSquaredMagnitude,
+        im: (left.im * right.re - left.re * right.im) / divisorSquaredMagnitude,
+        unit: combineUnitsForDivide(left.unit, right.unit)
+      });
+    }
+    case "modulo":
+      return indeterminate("domain-error", "'modulo' is undefined for complex values");
+    default:
+      throw new Error("unreachable arithmetic operator");
+  }
+}
+function applyComplexPower(base, exponent) {
+  if (exponent.kind !== "number" || !Number.isInteger(exponent.value)) return indeterminate("wrong-type", "'power' with a complex operand requires a real integer exponent");
+  if (!isDimensionless(base.unit) || !isDimensionless(exponent.unit)) return indeterminate("wrong-type", "'power' requires dimensionless operands");
+  const complexUnit = {
+    kind: "complex",
+    re: 1,
+    im: 0,
+    unit: {}
+  };
+  const complexBase = toComplexValue(base);
+  let repeatedProduct = complexUnit;
+  for (let applied = 0; applied < Math.abs(exponent.value); applied += 1) repeatedProduct = multiplyComplexValues(repeatedProduct, complexBase);
+  if (exponent.value >= 0) return definite(repeatedProduct);
+  return applyArithmeticOnComplex("divide", complexUnit, repeatedProduct);
+}
+function applyArithmetic(op, left, right) {
+  if (left.kind === "instant" && right.kind === "instant" && op === "subtract") {
+    const leftEpoch = toEpochMilliseconds(left.value);
+    if (leftEpoch === void 0) return unparseableInstant(left.value);
+    const rightEpoch = toEpochMilliseconds(right.value);
+    if (rightEpoch === void 0) return unparseableInstant(right.value);
+    return definite({
+      kind: "duration",
+      value: leftEpoch - rightEpoch,
+      unit: "ms"
+    });
+  }
+  if (left.kind === "instant" && right.kind === "duration" && op === "add") {
+    const leftEpoch = toEpochMilliseconds(left.value);
+    if (leftEpoch === void 0) return unparseableInstant(left.value);
+    return instantFromEpochMilliseconds(leftEpoch + toMilliseconds(right.value, right.unit));
+  }
+  if (left.kind === "duration" && right.kind === "instant" && op === "add") {
+    const rightEpoch = toEpochMilliseconds(right.value);
+    if (rightEpoch === void 0) return unparseableInstant(right.value);
+    return instantFromEpochMilliseconds(rightEpoch + toMilliseconds(left.value, left.unit));
+  }
+  if (left.kind === "instant" || right.kind === "instant") return indeterminate("wrong-type", `arithmetic operator '${op}' is not defined between a '${left.kind}' and a '${right.kind}' value`);
+  if (left.kind === "duration" && right.kind === "duration") return applyArithmeticOnDurations(op, left, right);
+  if (left.kind === "duration" || right.kind === "duration") return indeterminate("wrong-type", `arithmetic operator '${op}' is not defined between a '${left.kind}' and a '${right.kind}' value`);
+  if (left.kind !== "number" && left.kind !== "complex") return indeterminate("wrong-type", `arithmetic requires numeric operands; got a '${left.kind}' value`);
+  if (right.kind !== "number" && right.kind !== "complex") return indeterminate("wrong-type", `arithmetic requires numeric operands; got a '${right.kind}' value`);
+  if (left.kind === "complex" || right.kind === "complex") {
+    if (op === "power") return applyComplexPower(left, right);
+    return applyArithmeticOnComplex(op, toComplexValue(left), toComplexValue(right));
+  }
+  return applyArithmeticOnNumbers(op, left, right);
+}
+function checkReferenceUnit(expectedUnit, resolvedValue) {
+  if (expectedUnit === void 0) return void 0;
+  if (resolvedValue.kind !== "number" && resolvedValue.kind !== "complex") return indeterminate("wrong-type", "a unit was expected on a reference that resolved to a non-numeric value");
+  if (!unitsEqual(expectedUnit, resolvedValue.unit)) return indeterminate("wrong-type", "the resolved value's unit does not match the reference's expected unit");
+}
+function invokeRegisteredFunction(functions, fnName, args) {
+  const fn = Object.hasOwn(functions, fnName) ? functions[fnName] : void 0;
+  if (fn === void 0) return indeterminate("wrong-type", `no function registered under the name '${fnName}'`);
+  const outcome = fn(args);
+  if ("domainError" in outcome) return indeterminate("domain-error", outcome.domainError);
+  return definite(outcome);
+}
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/evaluator.js
+function* evaluatePredicateInternal(node2, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth) {
+  const budgetExceeded = budget.checkNode(nestingDepth);
+  if (budgetExceeded !== void 0) return budgetExceeded;
+  switch (node2.kind) {
+    case "not": {
+      const operand = yield* evaluatePredicateInternal(node2.operand, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+      if (operand.status === "indeterminate") return operand;
+      return definite(!operand.value);
+    }
+    case "and": {
+      const [left, right] = yield* all([evaluatePredicateInternal(node2.left, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1), evaluatePredicateInternal(node2.right, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1)]);
+      return combineAnd(left, right);
+    }
+    case "or": {
+      const [left, right] = yield* all([evaluatePredicateInternal(node2.left, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1), evaluatePredicateInternal(node2.right, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1)]);
+      return combineOr(left, right);
+    }
+    case "allOf":
+      return (yield* all(node2.operands.map((operand) => evaluatePredicateInternal(operand, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1)))).reduce(combineAnd, definite(true));
+    case "anyOf":
+      return (yield* all(node2.operands.map((operand) => evaluatePredicateInternal(operand, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1)))).reduce(combineOr, definite(false));
+    case "compare": {
+      const [left, right] = yield* all([evaluateValueInternal(node2.left, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1), evaluateValueInternal(node2.right, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1)]);
+      if (left.status === "indeterminate") return left;
+      if (right.status === "indeterminate") return right;
+      return compareValues(node2.op, left.value, right.value);
+    }
+    case "textCompare": {
+      const [left, right] = yield* all([evaluateValueInternal(node2.left, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1), evaluateValueInternal(node2.right, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1)]);
+      if (left.status === "indeterminate") return left;
+      if (right.status === "indeterminate") return right;
+      return compareText(node2.op, left.value, right.value);
+    }
+    case "memberOf": {
+      const operandResult = yield* evaluateValueInternal(node2.operand, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+      if (operandResult.status === "indeterminate") return operandResult;
+      const candidateOutcomes = yield* all(node2.candidates.map(function* (candidate) {
+        const candidateResult = yield* evaluateValueInternal(candidate, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+        if (candidateResult.status === "indeterminate") return candidateResult;
+        return computeMembershipMatch(operandResult.value, candidateResult.value);
+      }));
+      for (const outcome of candidateOutcomes) if (outcome.status === "definite" && outcome.value) return definite(node2.op === "in");
+      const reason = firstIndeterminate(...candidateOutcomes);
+      if (reason !== void 0) return {
+        status: "indeterminate",
+        reason
+      };
+      return definite(node2.op === "notIn");
+    }
+    case "exists": {
+      const operandResult = yield* evaluateValueInternal(node2.operand, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+      if (operandResult.status === "indeterminate" && operandResult.reason.code === "not-found") return definite(false);
+      return definite(true);
+    }
+    case "some":
+    case "every": {
+      const participating = yield* resolveParticipatingItems(evaluatePredicateInternal, node2.collection, node2.filter, context, resolvers, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+      const votes = (yield* all(participating.map(function* ({ item, filterOutcome }) {
+        if (filterOutcome === "exclude") return void 0;
+        if (filterOutcome !== "include") return filterOutcome;
+        return yield* evaluatePredicateInternal(node2.item, item, resolvers, void 0, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+      }))).filter((vote) => vote !== void 0);
+      const combine = node2.kind === "some" ? combineOr : combineAnd;
+      const identity = node2.kind === "some" ? definite(false) : definite(true);
+      return votes.reduce(combine, identity);
+    }
+    case "treeReference": {
+      if (resolvers.resolveTree === void 0) return indeterminate("wrong-type", "no tree resolver registered for treeReference nodes");
+      const keyString = JSON.stringify(node2.key);
+      if (visitedTreeKeys.has(keyString)) return indeterminate("domain-error", "circular treeReference detected");
+      if (treeReferenceDepth >= 100) return indeterminate("domain-error", `treeReference chain exceeds the maximum depth of ${100 .toString()}`);
+      const resolution = yield* wait(resolvers.resolveTree(node2.key, context));
+      if (!resolution.found) return indeterminate("not-found", "treeReference key did not resolve to a tree");
+      const parsed = PredicateNodeSchema.safeParse(resolution.node);
+      if (!parsed.success) return indeterminate("wrong-type", "the referenced tree is not a valid PredicateNode");
+      return yield* evaluatePredicateInternal(parsed.data, context, resolvers, accumulator, functions, /* @__PURE__ */ new Set([...visitedTreeKeys, keyString]), treeReferenceDepth + 1, budget, nestingDepth + 1);
+    }
+    default:
+      throw new Error("unreachable predicate node kind");
+  }
+}
+function* evaluateValueInternal(node2, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth) {
+  const budgetExceeded = budget.checkNode(nestingDepth);
+  if (budgetExceeded !== void 0) return budgetExceeded;
+  switch (node2.kind) {
+    case "reference": {
+      const resolution = yield* wait(resolvers.resolveValue(node2.key, context));
+      if (!resolution.found) return indeterminate("not-found", `no value found for reference key ${JSON.stringify(node2.key)}`);
+      const unitError = checkReferenceUnit(node2.unit, resolution.value);
+      if (unitError !== void 0) return unitError;
+      return definite(resolution.value);
+    }
+    case "accumulator":
+      if (accumulator === void 0) return indeterminate("wrong-type", "accumulator used outside a reduce fold's combine expression");
+      return definite(accumulator);
+    case "call": {
+      const argResults = yield* all(node2.args.map((arg) => evaluateValueInternal(arg, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1)));
+      const args = [];
+      for (const result of argResults) {
+        if (result.status === "indeterminate") return result;
+        args.push(result.value);
+      }
+      return invokeRegisteredFunction(functions, node2.fn, args);
+    }
+    case "numberLiteral":
+      return definite({
+        kind: "number",
+        value: node2.value,
+        unit: node2.unit
+      });
+    case "textLiteral":
+      return definite({
+        kind: "text",
+        value: node2.value
+      });
+    case "booleanLiteral":
+      return definite({
+        kind: "boolean",
+        value: node2.value
+      });
+    case "instantLiteral":
+      return definite({
+        kind: "instant",
+        value: node2.value
+      });
+    case "durationLiteral":
+      return definite({
+        kind: "duration",
+        value: node2.value,
+        unit: node2.unit
+      });
+    case "complexLiteral":
+      if ("re" in node2) return definite({
+        kind: "complex",
+        re: node2.re,
+        im: node2.im,
+        unit: node2.unit
+      });
+      return definite(complexFromPolar(node2.magnitude, node2.phase, node2.unit));
+    case "arithmetic": {
+      const [left, right] = yield* all([evaluateValueInternal(node2.left, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1), evaluateValueInternal(node2.right, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1)]);
+      if (left.status === "indeterminate") return left;
+      if (right.status === "indeterminate") return right;
+      return applyArithmetic(node2.op, left.value, right.value);
+    }
+    case "negate": {
+      const operand = yield* evaluateValueInternal(node2.operand, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+      if (operand.status === "indeterminate") return operand;
+      return applyNegate(operand.value);
+    }
+    case "lookup": {
+      const keyResults = yield* all(node2.keys.map((key) => evaluateValueInternal(key, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1)));
+      const keyValues = [];
+      for (const result of keyResults) {
+        if (result.status === "indeterminate") return result;
+        keyValues.push(result.value);
+      }
+      const resolution = yield* wait(resolvers.resolveLookup(node2.table, keyValues, context));
+      if (!resolution.found) return indeterminate("not-found", `no match found in lookup table ${JSON.stringify(node2.table)}`);
+      return definite(resolution.value);
+    }
+    case "conditional": {
+      if ((node2.hitPolicy ?? "first") === "first") {
+        for (const { when, then } of node2.cases) {
+          const whenResult = yield* evaluatePredicateInternal(when, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+          if (whenResult.status === "indeterminate") return whenResult;
+          if (whenResult.value) return yield* evaluateValueInternal(then, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+        }
+        return yield* evaluateValueInternal(node2.fallback, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+      }
+      const evaluatedCases = yield* all(node2.cases.map(function* ({ when, then }) {
+        return {
+          then,
+          whenResult: yield* evaluatePredicateInternal(when, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1)
+        };
+      }));
+      const matches = evaluatedCases.filter(({ whenResult }) => whenResult.status === "definite" && whenResult.value);
+      if (matches.length >= 2) return indeterminate("domain-error", "more than one case matched under the 'unique' hit policy");
+      const reason = firstIndeterminate(...evaluatedCases.map(({ whenResult }) => whenResult));
+      if (reason !== void 0) return {
+        status: "indeterminate",
+        reason
+      };
+      const [match] = matches;
+      if (match === void 0) return yield* evaluateValueInternal(node2.fallback, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+      return yield* evaluateValueInternal(match.then, context, resolvers, accumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+    }
+    case "fold": {
+      const participating = yield* resolveParticipatingItems(evaluatePredicateInternal, node2.collection, node2.filter, context, resolvers, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+      const filterIndeterminateReason = firstFilterIndeterminate(participating);
+      if (filterIndeterminateReason !== void 0) return {
+        status: "indeterminate",
+        reason: filterIndeterminateReason
+      };
+      const includedItems = participating.filter(({ filterOutcome }) => filterOutcome === "include").map(({ item }) => item);
+      if (node2.combiner.mode === "reduce") {
+        const initialResult = yield* evaluateValueInternal(node2.combiner.initial, context, resolvers, void 0, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+        if (initialResult.status === "indeterminate") return initialResult;
+        let runningAccumulator = initialResult.value;
+        for (const item of includedItems) {
+          const stepResult = yield* evaluateValueInternal(node2.combiner.combine, item, resolvers, runningAccumulator, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+          if (stepResult.status === "indeterminate") return stepResult;
+          runningAccumulator = stepResult.value;
+        }
+        return definite(runningAccumulator);
+      }
+      if (includedItems.length === 0) return indeterminate("domain-error", `'${node2.combiner.mode}' has no participating items to seed a running result from`);
+      const dominatesOp = node2.combiner.mode === "max" ? "gt" : "lt";
+      let runningExtremum;
+      for (const item of includedItems) {
+        const itemResult = yield* evaluateValueInternal(node2.combiner.item, item, resolvers, void 0, functions, visitedTreeKeys, treeReferenceDepth, budget, nestingDepth + 1);
+        if (itemResult.status === "indeterminate") return itemResult;
+        if (runningExtremum === void 0) {
+          runningExtremum = itemResult.value;
+          continue;
+        }
+        const comparison = compareValues(dominatesOp, itemResult.value, runningExtremum);
+        if (comparison.status === "indeterminate") return comparison;
+        if (comparison.value) runningExtremum = itemResult.value;
+      }
+      if (runningExtremum === void 0) throw new Error("unreachable: max/min over a non-empty participating list produced no running result");
+      return definite(runningExtremum);
+    }
+    case "delegate": {
+      if (resolvers.resolveDelegate === void 0) return indeterminate("wrong-type", `no delegate handler registered for external system '${node2.system}'`);
+      const resolution = yield* wait(resolvers.resolveDelegate(node2.system, node2.payload, context));
+      if (!resolution.found) return indeterminate("not-found", `delegate handler for external system '${node2.system}' reported no value`);
+      return definite(resolution.value);
+    }
+    case "treeReference": {
+      if (resolvers.resolveTree === void 0) return indeterminate("wrong-type", "no tree resolver registered for treeReference nodes");
+      const keyString = JSON.stringify(node2.key);
+      if (visitedTreeKeys.has(keyString)) return indeterminate("domain-error", "circular treeReference detected");
+      if (treeReferenceDepth >= 100) return indeterminate("domain-error", `treeReference chain exceeds the maximum depth of ${100 .toString()}`);
+      const resolution = yield* wait(resolvers.resolveTree(node2.key, context));
+      if (!resolution.found) return indeterminate("not-found", "treeReference key did not resolve to a tree");
+      const parsed = ExpressionNodeSchema.safeParse(resolution.node);
+      if (!parsed.success) return indeterminate("wrong-type", "the referenced tree is not a valid ExpressionNode");
+      return yield* evaluateValueInternal(parsed.data, context, resolvers, accumulator, functions, /* @__PURE__ */ new Set([...visitedTreeKeys, keyString]), treeReferenceDepth + 1, budget, nestingDepth + 1);
+    }
+    default:
+      throw new Error("unreachable expression node kind");
+  }
+}
+
+// node_modules/.pnpm/trilean@1.7.1/node_modules/trilean/dist/evaluator-factory.js
+function createEvaluator({ functions = emptyFunctionRegistry, maxNodes = DEFAULT_MAX_EVALUATION_NODES, maxNestingDepth = 500 }) {
+  return {
+    evaluatePredicate: async (node2, context, resolvers) => runAsync(evaluatePredicateInternal(node2, context, resolvers, void 0, functions, /* @__PURE__ */ new Set(), 0, createEvaluationBudget(maxNodes, maxNestingDepth), 0)),
+    evaluateValue: async (node2, context, resolvers) => runAsync(evaluateValueInternal(node2, context, resolvers, void 0, functions, /* @__PURE__ */ new Set(), 0, createEvaluationBudget(maxNodes, maxNestingDepth), 0))
+  };
+}
+function createSyncEvaluator({ functions = emptyFunctionRegistry, maxNodes = DEFAULT_MAX_EVALUATION_NODES, maxNestingDepth = 500 }) {
+  return {
+    evaluatePredicate: (node2, context, resolvers) => runSync(evaluatePredicateInternal(node2, context, resolvers, void 0, functions, /* @__PURE__ */ new Set(), 0, createEvaluationBudget(maxNodes, maxNestingDepth), 0)),
+    evaluateValue: (node2, context, resolvers) => runSync(evaluateValueInternal(node2, context, resolvers, void 0, functions, /* @__PURE__ */ new Set(), 0, createEvaluationBudget(maxNodes, maxNestingDepth), 0))
+  };
+}
+var { evaluatePredicate, evaluateValue } = createEvaluator({});
+
+// src/config/schema.ts
 var CATEGORY_NAMES = ["secret", "runtime", "history", "knowledge", "settings"];
 var OVERRIDABLE_CATEGORIES = ["runtime", "history", "knowledge", "settings"];
 function isOverridableCategory(name) {
@@ -55157,11 +56990,11 @@ function isCategoryName(name) {
   return CATEGORY_NAMES.some((category) => category === name);
 }
 function expandAllCategoryKey(pairs) {
-  const { all: all2, ...rest } = pairs;
-  if (all2 === void 0) {
+  const { all: all3, ...rest } = pairs;
+  if (all3 === void 0) {
     return { ...rest };
   }
-  const expanded = Object.fromEntries(OVERRIDABLE_CATEGORIES.filter((category) => !all2 || category !== "runtime").map((category) => [category, all2]));
+  const expanded = Object.fromEntries(OVERRIDABLE_CATEGORIES.filter((category) => !all3 || category !== "runtime").map((category) => [category, all3]));
   return { ...expanded, ...rest };
 }
 var CategoryMapSchema = external_exports.strictObject({
@@ -55173,13 +57006,14 @@ var CategoryMapSchema = external_exports.strictObject({
 }).transform((input2) => expandAllCategoryKey(input2));
 var DURATION_RE = /^(?:0|[1-9][0-9]*)(?:ms|s|m|h|d|w)$/;
 var DurationSchema = external_exports.string().regex(DURATION_RE);
-var WhenSchema = external_exports.strictObject({
+var WhenConditionObjectSchema = external_exports.strictObject({
   newerThan: DurationSchema.optional(),
   olderThan: DurationSchema.optional(),
   maxSizeBytes: external_exports.int().positive().optional(),
   branch: external_exports.string().min(1).optional(),
   env: external_exports.record(external_exports.string().min(1), external_exports.string()).optional()
 });
+var WhenSchema = external_exports.union([WhenConditionObjectSchema, PredicateNodeSchema]);
 var EntryValueSchema = external_exports.union([
   external_exports.boolean(),
   external_exports.strictObject({ value: external_exports.boolean(), when: WhenSchema })
@@ -59055,7 +60889,6 @@ function planReconciliation(params) {
 }
 
 // src/resolve/conditions.ts
-var import_picomatch2 = __toESM(require_picomatch2(), 1);
 var MILLISECONDS_PER_UNIT = Object.freeze({
   ms: 1,
   s: 1e3,
@@ -59080,62 +60913,85 @@ function parseDuration(value2) {
   }
   return Number(count) * multiplier;
 }
-function matchBranch(pattern, branch, detached = false) {
-  if (branch === void 0 || branch === "" || detached) {
-    return false;
+var evaluator = createSyncEvaluator({});
+function resolversOf(context) {
+  const values = {
+    now: context.nowMs,
+    ...context.fact?.latestMtimeMs === void 0 ? {} : { "entry.latestMtimeMs": context.fact.latestMtimeMs },
+    ...context.fact?.totalSizeBytes === void 0 ? {} : { "entry.totalSizeBytes": context.fact.totalSizeBytes },
+    ...context.branch === void 0 ? {} : { "repo.branch": context.branch },
+    "repo.detached": context.branchDetached ?? false
+  };
+  return {
+    resolveValue: (key) => {
+      const wrap = (value3) => ({ found: true, value: typeof value3 === "number" ? { kind: "number", value: value3 } : typeof value3 === "string" ? { kind: "text", value: value3 } : { kind: "boolean", value: value3 } });
+      if (typeof key !== "string") {
+        return { found: false };
+      }
+      if (key.startsWith("env.")) {
+        const value3 = context.env[key.slice("env.".length)];
+        return value3 === void 0 ? { found: false } : wrap(value3);
+      }
+      const value2 = values[key];
+      return value2 === void 0 ? { found: false } : wrap(value2);
+    },
+    // This embedding provides the reference namespace only: a tree that asks for a lookup or a collection finds neither, which the evaluator carries as indeterminate rather than letting the tree pretend an answer.
+    resolveLookup: () => ({ found: false }),
+    resolveCollection: () => []
+  };
+}
+function fieldPredicate(field, when, context) {
+  switch (field) {
+    case "newerThan": {
+      const window = parseDuration(when.newerThan ?? "");
+      return { kind: "compare", op: "gte", left: { kind: "reference", key: "entry.latestMtimeMs" }, right: { kind: "numberLiteral", value: context.nowMs - window } };
+    }
+    case "olderThan": {
+      const window = parseDuration(when.olderThan ?? "");
+      return { kind: "compare", op: "lt", left: { kind: "reference", key: "entry.latestMtimeMs" }, right: { kind: "numberLiteral", value: context.nowMs - window } };
+    }
+    case "maxSizeBytes":
+      return { kind: "compare", op: "lte", left: { kind: "reference", key: "entry.totalSizeBytes" }, right: { kind: "numberLiteral", value: when.maxSizeBytes ?? 0 } };
+    case "branch":
+      return { kind: "allOf", operands: [{ kind: "textCompare", op: "portableMatches", left: { kind: "reference", key: "repo.branch" }, right: { kind: "textLiteral", value: when.branch ?? "" } }, { kind: "compare", op: "eq", left: { kind: "reference", key: "repo.detached" }, right: { kind: "booleanLiteral", value: false } }] };
+    case "env": {
+      const entries = Object.entries(when.env ?? {});
+      return { kind: "allOf", operands: entries.map(([name, expected]) => ({ kind: "textCompare", op: "equals", left: { kind: "reference", key: `env.${name}` }, right: { kind: "textLiteral", value: expected } })) };
+    }
   }
-  return (0, import_picomatch2.default)(pattern, { dot: true, nocase: false })(branch);
+  return { kind: "allOf", operands: [] };
 }
 function evaluateWhen(when, context) {
   if (when === void 0) {
-    return { passed: true, checked: [], failed: [] };
+    return { status: "definite", passed: true, checked: [], failed: [] };
+  }
+  if ("kind" in when) {
+    const result = evaluator.evaluatePredicate(when, void 0, resolversOf(context));
+    return result.status === "indeterminate" ? { status: "indeterminate", reason: result.reason.message, checked: ["predicate"] } : { status: "definite", passed: result.value, checked: ["predicate"], failed: result.value ? [] : ["predicate"] };
   }
   const checked = [];
   const failed = [];
-  if (when.newerThan !== void 0) {
-    checked.push("newerThan");
-    const window = parseDuration(when.newerThan);
-    const latest = context.fact?.latestMtimeMs;
-    if (latest === void 0 || context.nowMs - latest > window) {
-      failed.push("newerThan");
-    }
-  }
-  if (when.olderThan !== void 0) {
-    checked.push("olderThan");
-    const window = parseDuration(when.olderThan);
-    const latest = context.fact?.latestMtimeMs;
-    if (latest === void 0 || context.nowMs - latest <= window) {
-      failed.push("olderThan");
-    }
-  }
-  if (when.maxSizeBytes !== void 0) {
-    checked.push("maxSizeBytes");
-    const total = context.fact?.totalSizeBytes;
-    if (total === void 0 || total > when.maxSizeBytes) {
-      failed.push("maxSizeBytes");
+  for (const field of ["newerThan", "olderThan", "maxSizeBytes", "branch", "env"]) {
+    if (when[field] === void 0) {
+      continue;
     }
-  }
-  if (when.branch !== void 0) {
-    checked.push("branch");
-    if (!matchBranch(when.branch, context.branch, context.branchDetached ?? false)) {
-      failed.push("branch");
+    checked.push(field);
+    const result = evaluator.evaluatePredicate(fieldPredicate(field, when, context), void 0, resolversOf(context));
+    if (result.status === "indeterminate") {
+      return { status: "indeterminate", reason: result.reason.message, checked };
     }
-  }
-  if (when.env !== void 0) {
-    checked.push("env");
-    const mismatch = Object.entries(when.env).some(([name, expected]) => context.env[name] !== expected);
-    if (mismatch) {
-      failed.push("env");
+    if (!result.value) {
+      failed.push(field);
     }
   }
-  return { passed: failed.length === 0, checked, failed };
+  return { status: "definite", passed: failed.length === 0, checked, failed };
 }
 function isVacuousWhen(when) {
-  return when !== void 0 && Object.keys(when).length === 0;
+  return when !== void 0 && !("kind" in when) && Object.keys(when).length === 0;
 }
 
 // src/resolve/match.ts
-var import_picomatch3 = __toESM(require_picomatch2(), 1);
+var import_picomatch2 = __toESM(require_picomatch2(), 1);
 
 // src/resolve/projects.ts
 var NON_ALPHANUMERIC = /[^A-Za-z0-9]/g;
@@ -59311,8 +61167,8 @@ function canonicaliseEntryKey(key, options) {
 }
 function compileMatcher(canonicalPattern) {
   const options = { dot: true, nocase: false };
-  const self = (0, import_picomatch3.default)(canonicalPattern, options);
-  const subtree = (0, import_picomatch3.default)(`${canonicalPattern}/**`, options);
+  const self = (0, import_picomatch2.default)(canonicalPattern, options);
+  const subtree = (0, import_picomatch2.default)(`${canonicalPattern}/**`, options);
   return (relPath) => self(relPath) || subtree(relPath);
 }
 function patternCouldReachUnder(canonicalPattern, dir) {
@@ -59335,7 +61191,7 @@ function couldReach(patternSegments, dirSegments) {
   if (head === void 0 || dirHead === void 0) {
     return true;
   }
-  if (!(0, import_picomatch3.default)(head, { dot: true, nocase: false })(dirHead)) {
+  if (!(0, import_picomatch2.default)(head, { dot: true, nocase: false })(dirHead)) {
     return false;
   }
   return couldReach(restPattern, restDir);
@@ -59502,10 +61358,10 @@ function selectRule(relPath, flattened, context) {
       ...context.branchDetached === void 0 ? {} : { branchDetached: context.branchDetached },
       env: context.env
     });
-    if (evaluation.passed) {
+    if (evaluation.status === "definite" && evaluation.passed) {
       return { rule, eliminated };
     }
-    eliminated.push({ rule, failed: evaluation.failed });
+    eliminated.push({ rule, failed: evaluation.status === "definite" ? evaluation.failed : [`${evaluation.checked.join(", ")} could not be decided: ${evaluation.reason}`] });
   }
   return { eliminated };
 }
@@ -59739,7 +61595,10 @@ function planFarm(params) {
 var ENTER_EVERYTHING = () => true;
 function readsSubtreeAggregates(rule) {
   const when = rule.when;
-  return when !== void 0 && (when.newerThan !== void 0 || when.olderThan !== void 0 || when.maxSizeBytes !== void 0);
+  if (when === void 0) {
+    return false;
+  }
+  return "kind" in when || when.newerThan !== void 0 || when.olderThan !== void 0 || when.maxSizeBytes !== void 0;
 }
 function hasUnboundedDepth(pattern) {
   return pattern.includes("**") || /[{(]/.test(pattern);
@@ -59759,11 +61618,11 @@ function couldMatchBeneath(rule, dirRel) {
   return prefix === "" || prefix.startsWith(`${dirRel}/`) || dirRel.startsWith(prefix);
 }
 function descendPolicy(rules) {
-  const all2 = [...rules];
-  if (all2.some(readsSubtreeAggregates)) {
+  const all3 = [...rules];
+  if (all3.some(readsSubtreeAggregates)) {
     return ENTER_EVERYTHING;
   }
-  return (dirRel) => all2.some((rule) => couldMatchBeneath(rule, dirRel));
+  return (dirRel) => all3.some((rule) => couldMatchBeneath(rule, dirRel));
 }
 function enterRulesAnd(policy, target) {
   if (target === void 0 || target === "") {
@@ -61796,7 +63655,7 @@ function registerIdentityCommand(program2, deps) {
 // package.json
 var package_default = {
   name: "agent-shim",
-  version: "8.31.0",
+  version: "8.33.0",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "MIT",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -61852,6 +63711,7 @@ var package_default = {
     commander: "^15.0.0",
     cosmiconfig: "^10.0.1",
     picomatch: "^4.0.7",
+    trilean: "1.7.1",
     undici: "7.29.1",
     zod: "^4.6.1"
   },
@@ -62512,7 +64372,7 @@ function createJsonScanner() {
     capture = "";
     inValue = false;
   };
-  const step = (char) => {
+  const step2 = (char) => {
     if (capturing !== void 0 && !(depth === 1 && !inString && (char === "," || char === "}"))) {
       capture += char;
     }
@@ -62579,7 +64439,7 @@ function createJsonScanner() {
   return {
     push: (text2) => {
       for (const char of text2) {
-        step(char);
+        step2(char);
       }
     },
     result: () => {
@@ -62775,10 +64635,10 @@ function windowBlockedUntil(windows) {
   const resets = windows.flatMap((window) => window.status === "rejected" && window.resetsAtMs !== void 0 ? [window.resetsAtMs] : []);
   return resets.length === 0 ? void 0 : Math.max(...resets);
 }
-function fiveHourBurn(records) {
+function windowBurn(records, which) {
   const points = [];
   for (const record2 of records) {
-    const window = record2.rateLimitHeaders === void 0 ? void 0 : parseUnifiedRateLimit(record2.rateLimitHeaders)?.fiveHour;
+    const window = record2.rateLimitHeaders === void 0 ? void 0 : parseUnifiedRateLimit(record2.rateLimitHeaders)?.[which];
     if (window?.utilization !== void 0 && window.resetsAt !== void 0) {
       points.push({ resetsAt: window.resetsAt, point: { atMs: Date.parse(record2.at), utilization: window.utilization } });
     }
@@ -62872,11 +64732,16 @@ function assessIdentity(member, nowMs) {
   const score = remaining * plan.capacity / (untilResetMs / MS_PER_HOUR);
   const fiveRemaining = five?.utilization === void 0 ? void 0 : Math.max(0, 1 - five.utilization);
   const fiveUntil = five?.resetsAtMs === void 0 ? FIVE_HOUR_WINDOW_MS : Math.max(five.resetsAtMs - nowMs, MS_PER_SECOND3);
-  const burn = fiveHourBurn(member.records);
+  const burn = windowBurn(member.records, "fiveHour");
+  const sevenRemaining = seven?.utilization === void 0 ? void 0 : Math.max(0, 1 - seven.utilization);
+  const sevenUntil = seven?.resetsAtMs === void 0 ? SEVEN_DAY_WINDOW_MS : Math.max(seven.resetsAtMs - nowMs, MS_PER_SECOND3);
+  const sevenDayBurn = windowBurn(member.records, "sevenDay");
   return {
     candidate: { ...base, class: "scored", score, reasons: [...windowReasons.map((reason, index) => index === windowReasons.length - 1 ? `${reason}${observedAgo}` : reason), ...planReasons] },
     ...fiveRemaining === void 0 ? {} : { fiveHour: { remaining: fiveRemaining, untilResetMs: fiveUntil } },
-    ...burn === void 0 ? {} : { burn }
+    ...burn === void 0 ? {} : { burn },
+    ...sevenRemaining === void 0 ? {} : { sevenDay: { remaining: sevenRemaining, untilResetMs: sevenUntil } },
+    ...sevenDayBurn === void 0 ? {} : { sevenDayBurn }
   };
 }
 function rankPool(input2) {
@@ -62887,14 +64752,27 @@ function rankPool(input2) {
   const candidates = assessments.map((assessment) => {
     const { candidate, fiveHour, burn } = assessment;
     const pace = burn ?? (sharedDemand === void 0 ? void 0 : sharedDemand / capacityOf(candidate.plan));
-    if (candidate.class !== "scored" || fiveHour === void 0 || pace === void 0) {
+    const { sevenDay, sevenDayBurn } = assessment;
+    if (candidate.class !== "scored") {
       return { ...candidate, feasible: true };
     }
-    const runsDryInMs = fiveHour.remaining / pace;
-    if (runsDryInMs >= fiveHour.untilResetMs) {
+    const drySpots = [];
+    if (fiveHour !== void 0 && pace !== void 0) {
+      const runsDryInMs = fiveHour.remaining / pace;
+      if (runsDryInMs < fiveHour.untilResetMs) {
+        drySpots.push(`5h window would run dry in ${formatAge(runsDryInMs)}, before it resets in ${formatAge(fiveHour.untilResetMs)}`);
+      }
+    }
+    if (sevenDay !== void 0 && sevenDayBurn !== void 0) {
+      const runsDryInMs = sevenDay.remaining / sevenDayBurn;
+      if (runsDryInMs < sevenDay.untilResetMs) {
+        drySpots.push(`7d window would run dry in ${formatAge(runsDryInMs)}, before it resets in ${formatAge(sevenDay.untilResetMs)}`);
+      }
+    }
+    if (drySpots.length === 0) {
       return { ...candidate, feasible: true };
     }
-    return { ...candidate, feasible: false, reasons: [`5h window would run dry in ${formatAge(runsDryInMs)}, before it resets in ${formatAge(fiveHour.untilResetMs)}`, ...candidate.reasons] };
+    return { ...candidate, feasible: false, reasons: [...drySpots, ...candidate.reasons] };
   });
   const ordered = input2.preference === "listed" ? [...candidates] : [...candidates].sort(
     (left, right) => CLASS_ORDER[left.class] - CLASS_ORDER[right.class] || Number(right.feasible) - Number(left.feasible) || (right.score ?? 0) - (left.score ?? 0) || left.identity.localeCompare(right.identity)
@@ -62902,7 +64780,8 @@ function rankPool(input2) {
   const sticky = input2.sticky;
   const stickyIndex = sticky === void 0 ? -1 : ordered.findIndex((candidate) => candidate.identity === sticky.identity);
   const stickyCandidate = ordered[stickyIndex];
-  if (sticky !== void 0 && stickyCandidate?.class === "scored" && stickyCandidate.feasible) {
+  const keepSticky = stickyCandidate?.class === "scored" && stickyCandidate.feasible;
+  if (sticky !== void 0 && keepSticky) {
     const ageMs = nowMs - Date.parse(sticky.at);
     const warm = ageMs <= PROMPT_CACHE_TTL_MS;
     if (input2.resuming || warm) {
@@ -62911,12 +64790,14 @@ function rankPool(input2) {
       ordered.unshift({ ...stickyCandidate, reasons: [why, ...stickyCandidate.reasons] });
     }
   }
+  const movedOff = sticky !== void 0 && input2.resuming && !keepSticky ? { identity: sticky.identity, reason: stickyCandidate?.reasons[0] ?? "no longer among the pool's members" } : void 0;
   const pick2 = ordered.find((candidate) => candidate.class !== "ineligible");
   const returns = ordered.flatMap((candidate) => candidate.blockedUntilMs === void 0 ? [] : [{ identity: candidate.identity, atMs: candidate.blockedUntilMs }]);
   const earliestReturn = returns.length === 0 ? void 0 : returns.reduce((soonest, entry) => entry.atMs < soonest.atMs ? entry : soonest);
   return {
     candidates: ordered,
-    ...pick2 === void 0 ? { ...earliestReturn === void 0 ? {} : { earliestReturn } } : { pick: pick2 }
+    ...pick2 === void 0 ? { ...earliestReturn === void 0 ? {} : { earliestReturn } } : { pick: pick2 },
+    ...movedOff === void 0 || pick2 === void 0 ? {} : { movedOff }
   };
 }
 
@@ -63332,6 +65213,7 @@ function collectPoolPick(params) {
     candidates: ranking.candidates.map(candidateView),
     missing: missing.map(({ identity }) => identity),
     ...ranking.earliestReturn === void 0 ? {} : { earliestReturn: { identity: ranking.earliestReturn.identity, at: new Date(ranking.earliestReturn.atMs).toISOString() } },
+    ...ranking.movedOff === void 0 ? {} : { movedOff: ranking.movedOff },
     ...sticky.problem === void 0 ? {} : { stickyProblem: sticky.problem }
   };
 }
@@ -69611,6 +71493,8 @@ var PoolPickReportSchema = external_exports.strictObject({
   missing: external_exports.array(external_exports.string()),
   /** When nothing can be picked, the soonest any member returns. */
   earliestReturn: external_exports.strictObject({ identity: external_exports.string(), at: external_exports.iso.datetime() }).optional(),
+  /** The member a resumed conversation started on but moved off, and why, when the ranking could not keep it. */
+  movedOff: external_exports.strictObject({ identity: external_exports.string(), reason: external_exports.string() }).optional(),
   /** Why the last-pick record could not be read, when that is the case. */
   stickyProblem: external_exports.string().optional()
 });
@@ -73084,7 +74968,7 @@ var StandardHandler = class {
         return runWithSpan(
           { name: `${request7.method} ${request7.url.pathname}` },
           async (span) => {
-            let step;
+            let step2;
             try {
               return await intercept(
                 this.interceptors,
@@ -73103,12 +74987,12 @@ var StandardHandler = class {
                   span?.updateName(`${ORPC_NAME}.${match.path.join("/")}`);
                   span?.setAttribute("rpc.system", ORPC_NAME);
                   span?.setAttribute("rpc.method", match.path.join("."));
-                  step = "decode_input";
+                  step2 = "decode_input";
                   let input2 = await runWithSpan(
                     { name: "decode_input" },
                     () => this.codec.decode(request22, match.params, match.procedure)
                   );
-                  step = void 0;
+                  step2 = void 0;
                   if (isAsyncIteratorObject(input2)) {
                     input2 = asyncIteratorWithSpan(
                       { name: "consume_event_iterator_input", signal: request22.signal },
@@ -73120,12 +75004,12 @@ var StandardHandler = class {
                     path: match.path,
                     interceptors: this.clientInterceptors
                   });
-                  step = "call_procedure";
+                  step2 = "call_procedure";
                   const output2 = await client(input2, {
                     signal: request22.signal,
                     lastEventId: flattenHeader(request22.headers["last-event-id"])
                   });
-                  step = void 0;
+                  step2 = void 0;
                   const response = this.codec.encode(output2, match.procedure);
                   return {
                     matched: true,
@@ -73134,10 +75018,10 @@ var StandardHandler = class {
                 }
               );
             } catch (e) {
-              if (step !== "call_procedure") {
+              if (step2 !== "call_procedure") {
                 setSpanError(span, e);
               }
-              const error62 = step === "decode_input" && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
+              const error62 = step2 === "decode_input" && !(e instanceof ORPCError) ? new ORPCError("BAD_REQUEST", {
                 message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
                 cause: e
               }) : toORPCError(e);
@@ -75221,17 +77105,17 @@ function createCodexRoute(ports) {
       const frames = async function* () {
         try {
           for await (const event of codexEvents(upstreamBody)) {
-            const step = relay.push(event);
-            for (const frame of step.frames) {
+            const step2 = relay.push(event);
+            for (const frame of step2.frames) {
               yield renderSseFrame(frame);
             }
-            if (step.completed !== void 0) {
-              logCompleted(step.completed.message, step.completed.usage);
+            if (step2.completed !== void 0) {
+              logCompleted(step2.completed.message, step2.completed.usage);
               return;
             }
-            if (step.failed !== void 0) {
-              ports.log(`${upstreamRequest.model} stream error: ${step.failed.message}`);
-              yield errorFrame(HTTP_STATUS.internalServerError, step.failed.message);
+            if (step2.failed !== void 0) {
+              ports.log(`${upstreamRequest.model} stream error: ${step2.failed.message}`);
+              yield errorFrame(HTTP_STATUS.internalServerError, step2.failed.message);
               return;
             }
           }
@@ -75253,14 +77137,14 @@ function createCodexRoute(ports) {
     }
     try {
       for await (const event of codexEvents(upstreamBody)) {
-        const step = relay.push(event);
-        if (step.completed !== void 0) {
-          logCompleted(step.completed.message, step.completed.usage);
-          return { status: HTTP_STATUS.ok, headers: { "Content-Type": "application/json", ...quota }, body: JSON.stringify(step.completed.message) };
+        const step2 = relay.push(event);
+        if (step2.completed !== void 0) {
+          logCompleted(step2.completed.message, step2.completed.usage);
+          return { status: HTTP_STATUS.ok, headers: { "Content-Type": "application/json", ...quota }, body: JSON.stringify(step2.completed.message) };
         }
-        if (step.failed !== void 0) {
-          ports.log(`${upstreamRequest.model} stream error: ${step.failed.message}`);
-          return errorResponse(HTTP_STATUS.internalServerError, step.failed.message);
+        if (step2.failed !== void 0) {
+          ports.log(`${upstreamRequest.model} stream error: ${step2.failed.message}`);
+          return errorResponse(HTTP_STATUS.internalServerError, step2.failed.message);
         }
       }
     } catch (error62) {
@@ -80682,11 +82566,11 @@ function formatRateLimit(state) {
   return `quota (as of ${state.observedAt}): ${[...parts, `status ${unified.status ?? "unknown"}`, ...unified.overageStatus === void 0 ? [] : [`extra usage ${unified.overageStatus}`]].join("; ")}`;
 }
 function formatLimit(limit) {
-  const wait = [
+  const wait2 = [
     ...limit.resetAt === void 0 ? [] : [`resets ${limit.resetAt}`],
     ...limit.retryAfterSeconds === void 0 ? [] : [`retry after ${String(limit.retryAfterSeconds)}s`]
   ];
-  return `last limit: ${limit.kind} (${String(limit.status)}) at ${limit.observedAt}${limit.window === void 0 ? "" : ` on the ${limit.window} window`}${wait.length === 0 ? "" : `, ${wait.join(", ")}`}`;
+  return `last limit: ${limit.kind} (${String(limit.status)}) at ${limit.observedAt}${limit.window === void 0 ? "" : ` on the ${limit.window} window`}${wait2.length === 0 ? "" : `, ${wait2.join(", ")}`}`;
 }
 var MONEY_DECIMALS = 2;
 var MS_PER_HOUR3 = 36e5;
@@ -81187,10 +83071,11 @@ function resolvePoolLaunch(params) {
     if (graph.ranking.candidates.length === 0) {
       return { ok: false, message: `agent-shim: no member of pool "${poolName}" is an existing identity.` };
     }
-    const { pick: pick2, earliestReturn } = graph.ranking;
+    const { pick: pick2, earliestReturn, movedOff } = graph.ranking;
     if (pick2 !== void 0) {
       recordStickyPick(params.usageFs, params.paths.usagePicksFile, params.cwd, pick2.identity, nowMs);
-      return { ok: true, identity: pick2.identity, explanation: `pool ${poolName}: ${pick2.reasons.slice(0, REASONS_LOGGED).join("; ")}` };
+      const move = movedOff === void 0 ? "" : `moved off ${movedOff.identity} (${movedOff.reason}); `;
+      return { ok: true, identity: pick2.identity, explanation: `pool ${poolName}: ${move}${pick2.reasons.slice(0, REASONS_LOGGED).join("; ")}` };
     }
     if (earliestReturn === void 0) {
       return { ok: false, message: `agent-shim: no member of pool "${poolName}" can be picked.` };