@thomasfosterau/effect-parse 0.1.0 → 0.3.0

package/src/Parser.ts

@@ -29,6 +29,7 @@
  *
  * @since 0.1.0
  */
+import * as Predicate from "effect/Predicate"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import { dual } from "effect/Function"
@@ -39,12 +40,15 @@ import { pipeArguments } from "effect/Pipeable"
 import * as Result from "effect/Result"
 import type { Contravariant, Covariant, Simplify } from "effect/Types"
 import type { ErrMode, Input, Slice, Source, TraceEvent } from "./Input.js"
-import { Fail, Failure, mergeExpected, mergeFailures, State } from "./Input.js"
+import { Fail, Failure, mergeExpected, mergeFailures, mergeTiedFailures, State } from "./Input.js"
 import type { ErrorKind } from "./ParseError.js"
 import * as ParseError from "./ParseError.js"
-import * as Compiler from "./internal/compiler/registry.js"
+import * as Registry from "./internal/compiler/registry.js"
 import * as Entries from "./internal/entries.js"
 import * as Resume from "./internal/resume.js"
+import * as Run from "./internal/run.js"
+import * as Stack from "./internal/stack.js"
+import { TiedFailures } from "./internal/ties.js"
 import type { Node } from "./internal/node.js"
 import { bounds, NodeId } from "./internal/node.js"
 
@@ -56,7 +60,7 @@ import { bounds, NodeId } from "./internal/node.js"
  * @since 0.1.0
  * @category type ids
  */
-export const TypeId: "~effect-parse/Parser" = "~effect-parse/Parser"
+export const TypeId = "~effect-parse/Parser" as const
 
 /**
  * A parser that consumes input of type `I`, producing a value of type `A`,
@@ -134,9 +138,11 @@ export declare namespace Parser {
    *
    * @since 0.1.0
    */
-  export type InputOf<P> = [P] extends [never] ? Input
-    : [P] extends [Parser<infer _A, infer _E, infer _R, infer I>] ? I
-    : never
+  export type InputOf<P> = [P] extends [never]
+    ? Input
+    : [P] extends [Parser<infer _A, infer _E, infer _R, infer I>]
+      ? I
+      : never
 }
 
 /**
@@ -158,10 +164,19 @@ export type Range = number | { readonly min?: number | undefined; readonly max?:
  * @since 0.1.0
  * @category models
  */
-export type Repeated<A, Rg> = Rg extends number ? number extends Rg ? Array<A> : Rg extends 0 ? Array<A> : NonEmpty<A>
-  : Rg extends { readonly min: infer M extends number } ? number extends M ? Array<A> : M extends 0 ? Array<A>
-    : NonEmpty<A>
-  : Array<A>
+export type Repeated<A, Rg> = Rg extends number
+  ? number extends Rg
+    ? Array<A>
+    : Rg extends 0
+      ? Array<A>
+      : NonEmpty<A>
+  : Rg extends { readonly min: infer M extends number }
+    ? number extends M
+      ? Array<A>
+      : M extends 0
+        ? Array<A>
+        : NonEmpty<A>
+    : Array<A>
 
 type NonEmpty<A> = [A, ...Array<A>]
 
@@ -241,7 +256,7 @@ class ParserImpl<A, E, R, I extends Input> implements Parser<A, E, R, I> {
  * @category guards
  */
 export const isParser = (u: unknown): u is Parser<unknown, unknown, unknown, never> =>
-  typeof u === "object" && u !== null && TypeId in u
+  Predicate.isObjectOrArray(u) && TypeId in u
 
 const isParserArg = (args: IArguments) => isParser(args[0])
 const isTwoParserArgs = (args: IArguments) => isParser(args[0]) && isParser(args[1])
@@ -306,8 +321,11 @@ const nodeOfParser = (p: Parser.Any): Node | undefined => (p as any)[NodeId]
 export const named: {
   (name: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>
   <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I>
-} = dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I> =>
-  new ParserImpl(self.step, name, nodeOfParser(self)))
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I> =>
+    new ParserImpl(self.step, name, nodeOfParser(self))
+)
 
 /**
  * A parser that consumes nothing and succeeds with the given value.
@@ -334,7 +352,7 @@ export const sync = <A>(evaluate: () => A): Parser<A, never, never, Input> =>
  * @since 0.1.0
  * @category constructors
  */
-export const empty: Parser<void, never, never, Input> = described(() => undefined, "empty", {
+export const empty: Parser<void, never, never, Input> = /*#__PURE__*/ described(() => undefined, "empty", {
   _tag: "Succeed",
   value: undefined
 })
@@ -374,7 +392,7 @@ const failBacktrack: Node = { _tag: "Fail", mode: "Backtrack" }
  * @since 0.1.0
  * @category constructors
  */
-export const reject: Parser<never, never, never, Input> = described<never, never, never, Input>(
+export const reject: Parser<never, never, never, Input> = /*#__PURE__*/ described<never, never, never, Input>(
   (state) => state.backtrack("Fail"),
   "reject",
   failBacktrack
@@ -400,7 +418,7 @@ export const failMessage = (message: string): Parser<never, never, never, Input>
  * @since 0.1.0
  * @category constructors
  */
-export const todo: Parser<never, never, never, Input> = described<never, never, never, Input>(
+export const todo: Parser<never, never, never, Input> = /*#__PURE__*/ described<never, never, never, Input>(
   (state) => state.failMessage("Cut", "Assert", "`todo` parser reached"),
   "todo",
   { _tag: "Fail", mode: "Cut" }
@@ -410,6 +428,11 @@ export const todo: Parser<never, never, never, Input> = described<never, never,
  * Lazily constructs a parser, which is needed to define recursive grammars.
  * The thunk is evaluated once, on first use.
  *
+ * Each level of recursion uses some of the call stack, interpreted or
+ * compiled, so input nested a few thousand levels deep exhausts it. The
+ * runners catch the overflow and fail with an unrecoverable `ParseError` of
+ * kind `"TooDeep"` at the offset reached, instead of throwing.
+ *
  * @example
  * ```ts
  * import { Parser, Token } from "@thomasfosterau/effect-parse"
@@ -431,7 +454,7 @@ export const suspend = <A, E = never, R = never, I extends Input = string>(
   let parser: Parser<A, E, R, I> | undefined
   return described((state) => (parser ??= evaluate()).step(state), "suspend", {
     _tag: "Suspend",
-    resolve: () => parser ??= evaluate()
+    resolve: () => (parser ??= evaluate())
   })
 }
 
@@ -441,7 +464,7 @@ export const suspend = <A, E = never, R = never, I extends Input = string>(
  * @since 0.1.0
  * @category constructors
  */
-export const location: Parser<number, never, never, Input> = described((state) => state.pos, "location", {
+export const location: Parser<number, never, never, Input> = /*#__PURE__*/ described((state) => state.pos, "location", {
   _tag: "Location"
 })
 
@@ -453,11 +476,15 @@ export const location: Parser<number, never, never, Input> = described((state) =
  * @since 0.1.0
  * @category constructors
  */
-export const eof: Parser<void, never, never, Input> = described((state) => {
-  if (state.pos < state.end) return state.backtrack("Eof", expectedEof)
-  if (state.partial) return state.incomplete(1, expectedEof)
-  return undefined
-}, "eof", { _tag: "Eof" })
+export const eof: Parser<void, never, never, Input> = /*#__PURE__*/ described(
+  (state) => {
+    if (state.pos < state.end) return state.backtrack("Eof", expectedEof)
+    if (state.partial) return state.incomplete(1, expectedEof)
+    return undefined
+  },
+  "eof",
+  { _tag: "Eof" }
+)
 
 const expectedEof = ["end of input"]
 
@@ -474,13 +501,20 @@ const expectedEof = ["end of input"]
 export const map: {
   <A, B>(f: (a: A) => B): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E, R, I>
   <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, E, R, I>
-} = dual(2, <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, E, R, I> => {
-  const step = self.step
-  return described((state) => {
-    const a = step(state)
-    return a === Fail ? Fail : f(a)
-  }, self.name, { _tag: "Map", self, f })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, E, R, I> => {
+    const step = self.step
+    return described(
+      (state) => {
+        const a = step(state)
+        return a === Fail ? Fail : f(a)
+      },
+      self.name,
+      { _tag: "Map", self, f }
+    )
+  }
+)
 
 /**
  * Builds an object from the `[key, value]` entries a parser returns, as
@@ -518,9 +552,9 @@ export const fromEntries = <K extends PropertyKey, V, E, R, I extends Input>(
 export const as: {
   <B>(value: B): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E, R, I>
   <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, value: B): Parser<B, E, R, I>
-} = dual(2, <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, value: B): Parser<B, E, R, I> => {
+} = /*#__PURE__*/ dual(2, <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, value: B): Parser<B, E, R, I> => {
   const step = self.step
-  return described((state) => step(state) === Fail ? Fail : value, self.name, { _tag: "As", self, value })
+  return described((state) => (step(state) === Fail ? Fail : value), self.name, { _tag: "As", self, value })
 })
 
 /**
@@ -529,8 +563,7 @@ export const as: {
  * @since 0.1.0
  * @category mapping
  */
-export const asVoid = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<void, E, R, I> =>
-  as(self, undefined)
+export const asVoid = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<void, E, R, I> => as(self, undefined)
 
 /**
  * Replaces the output of a parser with `Option.some(output)`.
@@ -550,14 +583,21 @@ export const asSome = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Pars
 export const tap: {
   <A>(f: (a: A) => void): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>
   <A, E, R, I extends Input>(self: Parser<A, E, R, I>, f: (a: A) => void): Parser<A, E, R, I>
-} = dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, f: (a: A) => void): Parser<A, E, R, I> => {
-  const step = self.step
-  return described((state) => {
-    const a = step(state)
-    if (a !== Fail) f(a)
-    return a
-  }, self.name, { _tag: "Tap", self, f })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, f: (a: A) => void): Parser<A, E, R, I> => {
+    const step = self.step
+    return described(
+      (state) => {
+        const a = step(state)
+        if (a !== Fail) f(a)
+        return a
+      },
+      self.name,
+      { _tag: "Tap", self, f }
+    )
+  }
+)
 
 /**
  * Uses the output of a parser to choose the parser that consumes the rest
@@ -574,16 +614,23 @@ export const flatMap: {
     self: Parser<A, E, R, I>,
     f: (a: A) => Parser<B, E2, R2, I2>
   ): Parser<B, E | E2, R | R2, I & I2>
-} = dual(2, <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
-  self: Parser<A, E, R, I>,
-  f: (a: A) => Parser<B, E2, R2, I2>
-): Parser<B, E | E2, R | R2, I & I2> => {
-  const step = self.step
-  return described((state) => {
-    const a = step(state)
-    return a === Fail ? Fail : f(a).step(state)
-  }, undefined, { _tag: "FlatMap", self, f })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
+    self: Parser<A, E, R, I>,
+    f: (a: A) => Parser<B, E2, R2, I2>
+  ): Parser<B, E | E2, R | R2, I & I2> => {
+    const step = self.step
+    return described(
+      (state) => {
+        const a = step(state)
+        return a === Fail ? Fail : f(a).step(state)
+      },
+      undefined,
+      { _tag: "FlatMap", self, f }
+    )
+  }
+)
 
 /**
  * Applies a second parser to the *output* of the first (winnow's
@@ -613,34 +660,37 @@ export const mapParser: {
     self: Parser<A, E, R, I>,
     inner: Parser<B, E2, R2, A>
   ): Parser<B, E | E2, R | R2, I>
-} = dual(2, <A extends Input, E, R, I extends Input, B, E2, R2>(
-  self: Parser<A, E, R, I>,
-  inner: Parser<B, E2, R2, A>
-): Parser<B, E | E2, R | R2, I> => {
-  const step = self.step
-  return make((state) => {
-    const start = state.pos
-    const a = step(state)
-    if (a === Fail) return Fail
-    const sub = new State(a, { context: state.context })
-    sub.tracer = state.tracer
-    sub.depth = state.depth
-    sub.recovered = state.recovered
-    const b = inner.step(sub)
-    if (b === Fail) {
-      const f = sub.failure
-      if (sub.encoding !== undefined) state.encoding = sub.encoding
-      // The inner input is usually a slice ending where the outer parser stopped
-      const base = Math.max(start, state.pos - a.length)
-      const offset = Math.min(base + f.offset, state.pos)
-      return state.failWith(
-        sub.mode === "Incomplete" ? "Backtrack" : sub.mode,
-        new Failure(offset, f.kind, f.expected, f.context, f.hasCause, f.cause, f.message, 0)
-      )
-    }
-    return b
-  })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A extends Input, E, R, I extends Input, B, E2, R2>(
+    self: Parser<A, E, R, I>,
+    inner: Parser<B, E2, R2, A>
+  ): Parser<B, E | E2, R | R2, I> => {
+    const step = self.step
+    return make((state) => {
+      const start = state.pos
+      const a = step(state)
+      if (a === Fail) return Fail
+      const sub = new State(a, { context: state.context })
+      sub.tracer = state.tracer
+      sub.depth = state.depth
+      sub.recovered = state.recovered
+      const b = inner.step(sub)
+      if (b === Fail) {
+        const f = sub.failure
+        if (sub.encoding !== undefined) state.encoding = sub.encoding
+        // The inner input is usually a slice ending where the outer parser stopped
+        const base = Math.max(start, state.pos - a.length)
+        const offset = Math.min(base + f.offset, state.pos)
+        return state.failWith(
+          sub.mode === "Incomplete" ? "Backtrack" : sub.mode,
+          new Failure(offset, f.kind, f.expected, f.context, f.hasCause, f.cause, f.message, 0)
+        )
+      }
+      return b
+    })
+  }
+)
 
 /**
  * Transforms the output of a parser with a function that may fail with a
@@ -659,21 +709,28 @@ export const tryMap: {
     self: Parser<A, E, R, I>,
     f: (a: A) => Result.Result<B, E2>
   ): Parser<B, E | E2, R, I>
-} = dual(2, <A, E, R, I extends Input, B, E2>(
-  self: Parser<A, E, R, I>,
-  f: (a: A) => Result.Result<B, E2>
-): Parser<B, E | E2, R, I> => {
-  const step = self.step
-  return described((state) => {
-    const start = state.pos
-    const a = step(state)
-    if (a === Fail) return Fail
-    const r = f(a)
-    if (Result.isSuccess(r)) return r.success
-    state.pos = start
-    return state.failCause("Backtrack", "Verify", r.failure)
-  }, self.name, { _tag: "TryMap", self, f })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B, E2>(
+    self: Parser<A, E, R, I>,
+    f: (a: A) => Result.Result<B, E2>
+  ): Parser<B, E | E2, R, I> => {
+    const step = self.step
+    return described(
+      (state) => {
+        const start = state.pos
+        const a = step(state)
+        if (a === Fail) return Fail
+        const r = f(a)
+        if (Result.isSuccess(r)) return r.success
+        state.pos = start
+        return state.failCause("Backtrack", "Verify", r.failure)
+      },
+      self.name,
+      { _tag: "TryMap", self, f }
+    )
+  }
+)
 
 /**
  * Like {@link tryMap}, but the function may throw. Thrown values become the
@@ -685,14 +742,18 @@ export const tryMap: {
 export const tryMapUnknown: {
   <A, B>(f: (a: A) => B): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E | unknown, R, I>
   <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, E | unknown, R, I>
-} = dual(2, <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, unknown, R, I> =>
-  tryMap(self, (a) => {
-    try {
-      return Result.succeed(f(a))
-    } catch (e) {
-      return Result.fail(e)
-    }
-  }))
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => B): Parser<B, unknown, R, I> =>
+    tryMap(self, (a) => {
+      try {
+        return Result.succeed(f(a))
+      } catch (e) {
+        if (Stack.isStackOverflow(e)) throw e
+        return Result.fail(e)
+      }
+    })
+)
 
 /**
  * Transforms the output of a parser with a function returning an `Option`;
@@ -705,21 +766,25 @@ export const tryMapUnknown: {
 export const filterMap: {
   <A, B>(f: (a: A) => Option.Option<B>): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E, R, I>
   <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => Option.Option<B>): Parser<B, E, R, I>
-} = dual(2, <A, E, R, I extends Input, B>(
-  self: Parser<A, E, R, I>,
-  f: (a: A) => Option.Option<B>
-): Parser<B, E, R, I> => {
-  const step = self.step
-  return described((state) => {
-    const start = state.pos
-    const a = step(state)
-    if (a === Fail) return Fail
-    const o = f(a)
-    if (Option.isSome(o)) return o.value
-    state.pos = start
-    return state.backtrack("Verify")
-  }, self.name, { _tag: "FilterMap", self, f })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, f: (a: A) => Option.Option<B>): Parser<B, E, R, I> => {
+    const step = self.step
+    return described(
+      (state) => {
+        const start = state.pos
+        const a = step(state)
+        if (a === Fail) return Fail
+        const o = f(a)
+        if (Option.isSome(o)) return o.value
+        state.pos = start
+        return state.backtrack("Verify")
+      },
+      self.name,
+      { _tag: "FilterMap", self, f }
+    )
+  }
+)
 
 /**
  * Keeps the output of a parser only if it satisfies a predicate, otherwise
@@ -735,16 +800,20 @@ export const filter: {
   <A>(predicate: (a: NoInfer<A>) => boolean): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>
   <A, E, R, I extends Input, B extends A>(self: Parser<A, E, R, I>, refinement: (a: A) => a is B): Parser<B, E, R, I>
   <A, E, R, I extends Input>(self: Parser<A, E, R, I>, predicate: (a: A) => boolean): Parser<A, E, R, I>
-} = dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, predicate: (a: A) => boolean) => {
+} = /*#__PURE__*/ dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, predicate: (a: A) => boolean) => {
   const step = self.step
-  return described<A, E, R, I>((state) => {
-    const start = state.pos
-    const a = step(state)
-    if (a === Fail) return Fail
-    if (predicate(a)) return a
-    state.pos = start
-    return state.backtrack("Verify")
-  }, self.name, { _tag: "Filter", self, predicate })
+  return described<A, E, R, I>(
+    (state) => {
+      const start = state.pos
+      const a = step(state)
+      if (a === Fail) return Fail
+      if (predicate(a)) return a
+      state.pos = start
+      return state.backtrack("Verify")
+    },
+    self.name,
+    { _tag: "Filter", self, predicate }
+  )
 })
 
 /**
@@ -773,21 +842,24 @@ export const filterOrFail: {
     predicate: (a: A) => boolean,
     orFailWith: (a: A) => E2
   ): Parser<A, E | E2, R, I>
-} = dual(3, <A, E, R, I extends Input, E2>(
-  self: Parser<A, E, R, I>,
-  predicate: (a: A) => boolean,
-  orFailWith: (a: A) => E2
-) => {
-  const step = self.step
-  return described<A, E | E2, R, I>((state) => {
-    const start = state.pos
-    const a = step(state)
-    if (a === Fail) return Fail
-    if (predicate(a)) return a
-    state.pos = start
-    return state.failCause("Backtrack", "Verify", orFailWith(a))
-  }, self.name, { _tag: "Filter", self, predicate })
-})
+} = /*#__PURE__*/ dual(
+  3,
+  <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, predicate: (a: A) => boolean, orFailWith: (a: A) => E2) => {
+    const step = self.step
+    return described<A, E | E2, R, I>(
+      (state) => {
+        const start = state.pos
+        const a = step(state)
+        if (a === Fail) return Fail
+        if (predicate(a)) return a
+        state.pos = start
+        return state.failCause("Backtrack", "Verify", orFailWith(a))
+      },
+      self.name,
+      { _tag: "Filter", self, predicate }
+    )
+  }
+)
 
 // -----------------------------------------------------------------------------
 // Consumed input
@@ -802,10 +874,14 @@ export const filterOrFail: {
  */
 export const taken = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<Slice<I>, E, R, I> => {
   const step = self.step
-  return described((state) => {
-    const start = state.pos
-    return step(state) === Fail ? Fail : state.slice(start, state.pos)
-  }, self.name, { _tag: "Taken", self, encoding: undefined })
+  return described(
+    (state) => {
+      const start = state.pos
+      return step(state) === Fail ? Fail : state.slice(start, state.pos)
+    },
+    self.name,
+    { _tag: "Taken", self, encoding: undefined }
+  )
 }
 
 /**
@@ -819,11 +895,15 @@ export const withTaken = <A, E, R, I extends Input>(
   self: Parser<A, E, R, I>
 ): Parser<[output: A, taken: Slice<I>], E, R, I> => {
   const step = self.step
-  return described((state) => {
-    const start = state.pos
-    const a = step(state)
-    return a === Fail ? Fail : [a, state.slice(start, state.pos)]
-  }, self.name, { _tag: "WithTaken", self })
+  return described(
+    (state) => {
+      const start = state.pos
+      const a = step(state)
+      return a === Fail ? Fail : [a, state.slice(start, state.pos)]
+    },
+    self.name,
+    { _tag: "WithTaken", self }
+  )
 }
 
 /**
@@ -835,10 +915,14 @@ export const withTaken = <A, E, R, I extends Input>(
  */
 export const span = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<Span, E, R, I> => {
   const step = self.step
-  return described((state) => {
-    const start = state.pos
-    return step(state) === Fail ? Fail : { start, end: state.pos }
-  }, self.name, { _tag: "Span", self })
+  return described(
+    (state) => {
+      const start = state.pos
+      return step(state) === Fail ? Fail : { start, end: state.pos }
+    },
+    self.name,
+    { _tag: "Span", self }
+  )
 }
 
 /**
@@ -848,13 +932,19 @@ export const span = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser
  * @since 0.1.0
  * @category consumed input
  */
-export const withSpan = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<[output: A, span: Span], E, R, I> => {
+export const withSpan = <A, E, R, I extends Input>(
+  self: Parser<A, E, R, I>
+): Parser<[output: A, span: Span], E, R, I> => {
   const step = self.step
-  return described((state) => {
-    const start = state.pos
-    const a = step(state)
-    return a === Fail ? Fail : [a, { start, end: state.pos }]
-  }, self.name, { _tag: "WithSpan", self })
+  return described(
+    (state) => {
+      const start = state.pos
+      const a = step(state)
+      return a === Fail ? Fail : [a, { start, end: state.pos }]
+    },
+    self.name,
+    { _tag: "WithSpan", self }
+  )
 }
 
 // -----------------------------------------------------------------------------
@@ -867,11 +957,15 @@ const changeMode = <A, E, R, I extends Input>(
   to: ErrMode
 ): Parser<A, E, R, I> => {
   const step = self.step
-  return described((state) => {
-    const a = step(state)
-    if (a === Fail && state.mode === from) state.mode = to
-    return a
-  }, self.name, { _tag: "Mode", self, from, to })
+  return described(
+    (state) => {
+      const a = step(state)
+      if (a === Fail && state.mode === from) state.mode = to
+      return a
+    },
+    self.name,
+    { _tag: "Mode", self, from, to }
+  )
 }
 
 /**
@@ -890,8 +984,29 @@ const changeMode = <A, E, R, I extends Input>(
  * @since 0.1.0
  * @category error management
  */
-export const cut = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> =>
-  changeMode(self, "Backtrack", "Cut")
+export const cut = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> => {
+  const step = self.step
+  return described(
+    (state) => {
+      // A committed failure is reported where it happened (winnow's
+      // `cut_err`): only failures recorded inside `self` can outrank it as the
+      // furthest failure, not ones from abandoned branches or lookaheads before
+      // the commit.
+      const deepest = state.deepest
+      state.deepest = undefined
+      const a = step(state)
+      if (a === Fail && state.mode !== "Incomplete") {
+        state.mode = "Cut"
+        return a
+      }
+      const inner = state.deepest as Failure | undefined
+      if (deepest !== undefined && (inner === undefined || deepest.offset > inner.offset)) state.deepest = deepest
+      return a
+    },
+    self.name,
+    { _tag: "Mode", self, from: "Backtrack", to: "Cut" }
+  )
+}
 
 /**
  * Turns unrecoverable failures back into recoverable ones (winnow's
@@ -912,15 +1027,19 @@ export const backtrack = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): P
  */
 export const complete = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> => {
   const step = self.step
-  return described((state) => {
-    const start = state.pos
-    const a = step(state)
-    if (a === Fail && state.mode === "Incomplete") {
-      state.pos = start
-      return state.backtrack("Complete")
-    }
-    return a
-  }, self.name, { _tag: "Mode", self, from: "Incomplete", to: "Backtrack" })
+  return described(
+    (state) => {
+      const start = state.pos
+      const a = step(state)
+      if (a === Fail && state.mode === "Incomplete") {
+        state.pos = start
+        return state.backtrack("Complete")
+      }
+      return a
+    },
+    self.name,
+    { _tag: "Mode", self, from: "Incomplete", to: "Backtrack" }
+  )
 }
 
 /**
@@ -934,25 +1053,22 @@ export const complete = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Pa
 export const context: {
   (label: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>
   <A, E, R, I extends Input>(self: Parser<A, E, R, I>, label: string): Parser<A, E, R, I>
-} = dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, label: string): Parser<A, E, R, I> => {
+} = /*#__PURE__*/ dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, label: string): Parser<A, E, R, I> => {
   const step = self.step
-  return described((state) => {
-    const a = step(state)
-    if (a === Fail && state.mode !== "Incomplete") {
-      const f = state.failure
-      state.replaceFailure(new Failure(
-        f.offset,
-        f.kind,
-        f.expected,
-        [...f.context, label],
-        f.hasCause,
-        f.cause,
-        f.message,
-        f.needed
-      ))
-    }
-    return a
-  }, self.name ?? label, { _tag: "Context", self, label })
+  return described(
+    (state) => {
+      const a = step(state)
+      if (a === Fail && state.mode !== "Incomplete") {
+        const f = state.failure
+        state.replaceFailure(
+          new Failure(f.offset, f.kind, f.expected, [...f.context, label], f.hasCause, f.cause, f.message, f.needed)
+        )
+      }
+      return a
+    },
+    self.name ?? label,
+    { _tag: "Context", self, label }
+  )
 })
 
 /**
@@ -967,22 +1083,31 @@ export const context: {
 export const expected: {
   (description: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>
   <A, E, R, I extends Input>(self: Parser<A, E, R, I>, description: string): Parser<A, E, R, I>
-} = dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, description: string): Parser<A, E, R, I> => {
-  const step = self.step
-  const desc = [description]
-  return described((state) => {
-    const start = state.pos
-    const hintOffset = state.hintOffset
-    const hintExpected = state.hintExpected
-    const a = step(state)
-    if (a === Fail && state.failure.offset === start) {
-      const f = state.failure
-      const expected = hintOffset === start ? mergeExpected(hintExpected, desc) : desc
-      state.replaceFailure(new Failure(f.offset, f.kind, expected, f.context, f.hasCause, f.cause, f.message, f.needed))
-    }
-    return a
-  }, description, { _tag: "Expected", self, description })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, description: string): Parser<A, E, R, I> => {
+    const step = self.step
+    const desc = [description]
+    return described(
+      (state) => {
+        const start = state.pos
+        const hintOffset = state.hintOffset
+        const hintExpected = state.hintExpected
+        const a = step(state)
+        if (a === Fail && state.failure.offset === start) {
+          const f = state.failure
+          const expected = hintOffset === start ? mergeExpected(hintExpected, desc) : desc
+          state.replaceFailure(
+            new Failure(f.offset, f.kind, expected, f.context, f.hasCause, f.cause, f.message, f.needed)
+          )
+        }
+        return a
+      },
+      description,
+      { _tag: "Expected", self, description }
+    )
+  }
+)
 
 /**
  * Transforms the user error (cause) of a parser's failures.
@@ -993,17 +1118,26 @@ export const expected: {
 export const mapError: {
   <E, E2>(f: (e: E) => E2): <A, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E2, R, I>
   <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, f: (e: E) => E2): Parser<A, E2, R, I>
-} = dual(2, <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, f: (e: E) => E2): Parser<A, E2, R, I> => {
-  const step = self.step
-  return described((state) => {
-    const a = step(state)
-    if (a === Fail && state.failure.hasCause) {
-      const x = state.failure
-      state.replaceFailure(new Failure(x.offset, x.kind, x.expected, x.context, true, f(x.cause as E), x.message, x.needed))
-    }
-    return a
-  }, self.name, { _tag: "MapError", self })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, f: (e: E) => E2): Parser<A, E2, R, I> => {
+    const step = self.step
+    return described(
+      (state) => {
+        const a = step(state)
+        if (a === Fail && state.failure.hasCause) {
+          const x = state.failure
+          state.replaceFailure(
+            new Failure(x.offset, x.kind, x.expected, x.context, true, f(x.cause as E), x.message, x.needed)
+          )
+        }
+        return a
+      },
+      self.name,
+      { _tag: "MapError", self }
+    )
+  }
+)
 
 /**
  * Replaces any failure of a parser with the given user error, keeping the
@@ -1015,18 +1149,25 @@ export const mapError: {
 export const orFail: {
   <E2>(error: () => E2): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E2, R, I>
   <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, error: () => E2): Parser<A, E2, R, I>
-} = dual(2, <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, error: () => E2): Parser<A, E2, R, I> => {
-  const step = self.step
-  return described((state) => {
-    const start = state.pos
-    const a = step(state)
-    if (a === Fail && state.mode !== "Incomplete") {
-      const x = state.failure
-      state.replaceFailure(new Failure(start, x.kind, [], x.context, true, error(), undefined, 0))
-    }
-    return a
-  }, self.name, { _tag: "OrFail", self })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, E2>(self: Parser<A, E, R, I>, error: () => E2): Parser<A, E2, R, I> => {
+    const step = self.step
+    return described(
+      (state) => {
+        const start = state.pos
+        const a = step(state)
+        if (a === Fail && state.mode !== "Incomplete") {
+          const x = state.failure
+          state.replaceFailure(new Failure(start, x.kind, [], x.context, true, error(), undefined, 0))
+        }
+        return a
+      },
+      self.name,
+      { _tag: "OrFail", self }
+    )
+  }
+)
 
 /**
  * If the parser fails recoverably, tries `that` from the same position.
@@ -1043,10 +1184,13 @@ export const orElse: {
     self: Parser<A, E, R, I>,
     that: () => Parser<B, E2, R2, I2>
   ): Parser<A | B, E | E2, R | R2, I & I2>
-} = dual(2, <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
-  self: Parser<A, E, R, I>,
-  that: () => Parser<B, E2, R2, I2>
-): Parser<A | B, E | E2, R | R2, I & I2> => alt(self, suspend(that)))
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
+    self: Parser<A, E, R, I>,
+    that: () => Parser<B, E2, R2, I2>
+  ): Parser<A | B, E | E2, R | R2, I & I2> => alt(self, suspend(that))
+)
 
 /**
  * If the parser fails recoverably, succeeds with the given value without
@@ -1058,17 +1202,24 @@ export const orElse: {
 export const orElseSucceed: {
   <B>(value: () => B): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A | B, E, R, I>
   <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, value: () => B): Parser<A | B, E, R, I>
-} = dual(2, <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, value: () => B): Parser<A | B, E, R, I> => {
-  const step = self.step
-  return described((state) => {
-    const start = state.pos
-    const a = step(state)
-    if (a !== Fail) return a
-    if (state.mode !== "Backtrack") return Fail
-    recover(state, start)
-    return value()
-  }, self.name, { _tag: "OrElseSucceed", self, value })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, value: () => B): Parser<A | B, E, R, I> => {
+    const step = self.step
+    return described(
+      (state) => {
+        const start = state.pos
+        const a = step(state)
+        if (a !== Fail) return a
+        if (state.mode !== "Backtrack") return Fail
+        recover(state, start)
+        return value()
+      },
+      self.name,
+      { _tag: "OrElseSucceed", self, value }
+    )
+  }
+)
 
 /** Rewinds after a recoverable failure, remembering it as a hint. */
 const recover = (state: State<any>, start: number): void => {
@@ -1093,14 +1244,18 @@ const recover = (state: State<any>, start: number): void => {
  */
 export const opt = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<Option.Option<A>, E, R, I> => {
   const step = self.step
-  return described((state) => {
-    const start = state.pos
-    const a = step(state)
-    if (a !== Fail) return Option.some(a)
-    if (state.mode !== "Backtrack") return Fail
-    recover(state, start)
-    return Option.none()
-  }, self.name, { _tag: "Opt", self })
+  return described(
+    (state) => {
+      const start = state.pos
+      const a = step(state)
+      if (a !== Fail) return Option.some(a)
+      if (state.mode !== "Backtrack") return Fail
+      recover(state, start)
+      return Option.none()
+    },
+    self.name,
+    { _tag: "Opt", self }
+  )
 }
 
 /**
@@ -1122,7 +1277,7 @@ export const optional = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Pa
 export const cond = <A, E, R, I extends Input>(
   condition: boolean,
   self: Parser<A, E, R, I>
-): Parser<Option.Option<A>, E, R, I> => condition ? asSome(self) : succeed(Option.none())
+): Parser<Option.Option<A>, E, R, I> => (condition ? asSome(self) : succeed(Option.none()))
 
 /**
  * Runs a parser without consuming input (winnow's and nom's `peek`).
@@ -1132,18 +1287,26 @@ export const cond = <A, E, R, I extends Input>(
  */
 export const peek = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<A, E, R, I> => {
   const step = self.step
-  return described((state) => {
-    const start = state.pos
-    const hintOffset = state.hintOffset
-    const hintExpected = state.hintExpected
-    const a = step(state)
-    if (a !== Fail) {
-      state.pos = start
-      state.hintOffset = hintOffset
-      state.hintExpected = hintExpected
-    }
-    return a
-  }, self.name, { _tag: "Peek", self })
+  return described(
+    (state) => {
+      const start = state.pos
+      const hintOffset = state.hintOffset
+      const hintExpected = state.hintExpected
+      const deepest = state.deepest
+      const a = step(state)
+      if (a !== Fail) {
+        // Failures inside a lookahead that succeeded are about input that was
+        // never consumed, so they are not reported as the furthest failure
+        state.pos = start
+        state.hintOffset = hintOffset
+        state.hintExpected = hintExpected
+        state.deepest = deepest
+      }
+      return a
+    },
+    self.name,
+    { _tag: "Peek", self }
+  )
 }
 
 /**
@@ -1155,21 +1318,29 @@ export const peek = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser
  */
 export const not = <A, E, R, I extends Input>(self: Parser<A, E, R, I>): Parser<void, E, R, I> => {
   const step = self.step
-  return described((state) => {
-    const start = state.pos
-    const hintOffset = state.hintOffset
-    const hintExpected = state.hintExpected
-    const a = step(state)
-    if (a !== Fail) {
+  return described(
+    (state) => {
+      const start = state.pos
+      const hintOffset = state.hintOffset
+      const hintExpected = state.hintExpected
+      const deepest = state.deepest
+      const a = step(state)
+      if (a !== Fail) {
+        // The failures inside `self` are not this parser's failure
+        state.pos = start
+        state.deepest = deepest
+        return state.backtrack("Not")
+      }
+      if (state.mode !== "Backtrack") return Fail
       state.pos = start
-      return state.backtrack("Not")
-    }
-    if (state.mode !== "Backtrack") return Fail
-    state.pos = start
-    state.hintOffset = hintOffset
-    state.hintExpected = hintExpected
-    return undefined
-  }, self.name, { _tag: "Not", self })
+      state.hintOffset = hintOffset
+      state.hintExpected = hintExpected
+      state.deepest = deepest
+      return undefined
+    },
+    self.name,
+    { _tag: "Not", self }
+  )
 }
 
 /**
@@ -1202,15 +1373,19 @@ export const seq = <const Ps extends ReadonlyArray<Parser.Any>>(
 > => {
   const steps = parsers.map((p) => p.step)
   const n = steps.length
-  return described((state: State<any>) => {
-    const out = new Array(n)
-    for (let i = 0; i < n; i++) {
-      const a = steps[i]!(state)
-      if (a === Fail) return Fail
-      out[i] = a
-    }
-    return out as any
-  }, "seq", { _tag: "Seq", parsers, output: "tuple" })
+  return described(
+    (state: State<any>) => {
+      const out = new Array(n)
+      for (let i = 0; i < n; i++) {
+        const a = steps[i](state)
+        if (a === Fail) return Fail
+        out[i] = a
+      }
+      return out as any
+    },
+    "seq",
+    { _tag: "Seq", parsers, output: "tuple" }
+  )
 }
 
 /**
@@ -1230,17 +1405,21 @@ export const struct = <const Fields extends Readonly<Record<string, Parser.Any>>
   Parser.InputOf<Fields[keyof Fields]>
 > => {
   const keys = Object.keys(fields)
-  const steps = keys.map((k) => fields[k]!.step)
+  const steps = keys.map((k) => fields[k].step)
   const n = keys.length
-  return described((state: State<any>) => {
-    const out: Record<string, unknown> = {}
-    for (let i = 0; i < n; i++) {
-      const a = steps[i]!(state)
-      if (a === Fail) return Fail
-      out[keys[i]!] = a
-    }
-    return out as any
-  }, "struct", { _tag: "Struct", keys, parsers: keys.map((k) => fields[k]!) })
+  return described(
+    (state: State<any>) => {
+      const out: Record<string, unknown> = {}
+      for (let i = 0; i < n; i++) {
+        const a = steps[i](state)
+        if (a === Fail) return Fail
+        out[keys[i]] = a
+      }
+      return out as any
+    },
+    "struct",
+    { _tag: "Struct", keys, parsers: keys.map((k) => fields[k]) }
+  )
 }
 
 /**
@@ -1257,10 +1436,13 @@ export const zip: {
     self: Parser<A, E, R, I>,
     that: Parser<B, E2, R2, I2>
   ): Parser<[A, B], E | E2, R | R2, I & I2>
-} = dual(2, <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
-  self: Parser<A, E, R, I>,
-  that: Parser<B, E2, R2, I2>
-): Parser<[A, B], E | E2, R | R2, I & I2> => zipWith(self, that, (a, b) => [a, b]))
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
+    self: Parser<A, E, R, I>,
+    that: Parser<B, E2, R2, I2>
+  ): Parser<[A, B], E | E2, R | R2, I & I2> => zipWith(self, that, (a, b) => [a, b])
+)
 
 /**
  * Runs two parsers in sequence and combines their outputs.
@@ -1278,21 +1460,28 @@ export const zipWith: {
     that: Parser<B, E2, R2, I2>,
     f: (a: A, b: B) => C
   ): Parser<C, E | E2, R | R2, I & I2>
-} = dual(3, <A, E, R, I extends Input, B, E2, R2, I2 extends Input, C>(
-  self: Parser<A, E, R, I>,
-  that: Parser<B, E2, R2, I2>,
-  f: (a: A, b: B) => C
-): Parser<C, E | E2, R | R2, I & I2> => {
-  const s1 = self.step
-  const s2 = that.step
-  return described((state) => {
-    const a = s1(state)
-    if (a === Fail) return Fail
-    const b = s2(state)
-    if (b === Fail) return Fail
-    return f(a, b)
-  }, undefined, { _tag: "ZipWith", self, that, f })
-})
+} = /*#__PURE__*/ dual(
+  3,
+  <A, E, R, I extends Input, B, E2, R2, I2 extends Input, C>(
+    self: Parser<A, E, R, I>,
+    that: Parser<B, E2, R2, I2>,
+    f: (a: A, b: B) => C
+  ): Parser<C, E | E2, R | R2, I & I2> => {
+    const s1 = self.step
+    const s2 = that.step
+    return described(
+      (state) => {
+        const a = s1(state)
+        if (a === Fail) return Fail
+        const b = s2(state)
+        if (b === Fail) return Fail
+        return f(a, b)
+      },
+      undefined,
+      { _tag: "ZipWith", self, that, f }
+    )
+  }
+)
 
 /**
  * Runs two parsers in sequence, keeping the output of the first.
@@ -1308,10 +1497,13 @@ export const zipLeft: {
     self: Parser<A, E, R, I>,
     that: Parser<B, E2, R2, I2>
   ): Parser<A, E | E2, R | R2, I & I2>
-} = dual(2, <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
-  self: Parser<A, E, R, I>,
-  that: Parser<B, E2, R2, I2>
-): Parser<A, E | E2, R | R2, I & I2> => terminated(self, that))
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
+    self: Parser<A, E, R, I>,
+    that: Parser<B, E2, R2, I2>
+  ): Parser<A, E | E2, R | R2, I & I2> => terminated(self, that)
+)
 
 /**
  * Runs two parsers in sequence, keeping the output of the second.
@@ -1327,10 +1519,13 @@ export const zipRight: {
     self: Parser<A, E, R, I>,
     that: Parser<B, E2, R2, I2>
   ): Parser<B, E | E2, R | R2, I & I2>
-} = dual(2, <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
-  self: Parser<A, E, R, I>,
-  that: Parser<B, E2, R2, I2>
-): Parser<B, E | E2, R | R2, I & I2> => preceded(self, that))
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
+    self: Parser<A, E, R, I>,
+    that: Parser<B, E2, R2, I2>
+  ): Parser<B, E | E2, R | R2, I & I2> => preceded(self, that)
+)
 
 /**
  * Runs `prefix` then `parser`, keeping the output of `parser` (winnow's and
@@ -1345,7 +1540,7 @@ export const preceded = <A1, E1, R1, I1 extends Input, A2, E2, R2, I2 extends In
 ): Parser<A2, E1 | E2, R1 | R2, I1 & I2> => {
   const s1 = prefix.step
   const s2 = parser.step
-  return described((state) => s1(state) === Fail ? Fail : s2(state), parser.name, {
+  return described((state) => (s1(state) === Fail ? Fail : s2(state)), parser.name, {
     _tag: "Seq",
     parsers: [prefix, parser],
     output: 1
@@ -1365,11 +1560,15 @@ export const terminated = <A1, E1, R1, I1 extends Input, A2, E2, R2, I2 extends
 ): Parser<A1, E1 | E2, R1 | R2, I1 & I2> => {
   const s1 = parser.step
   const s2 = suffix.step
-  return described((state) => {
-    const a = s1(state)
-    if (a === Fail) return Fail
-    return s2(state) === Fail ? Fail : a
-  }, parser.name, { _tag: "Seq", parsers: [parser, suffix], output: 0 })
+  return described(
+    (state) => {
+      const a = s1(state)
+      if (a === Fail) return Fail
+      return s2(state) === Fail ? Fail : a
+    },
+    parser.name,
+    { _tag: "Seq", parsers: [parser, suffix], output: 0 }
+  )
 }
 
 /**
@@ -1379,20 +1578,7 @@ export const terminated = <A1, E1, R1, I1 extends Input, A2, E2, R2, I2 extends
  * @since 0.1.0
  * @category sequencing
  */
-export const delimited = <
-  A1,
-  E1,
-  R1,
-  I1 extends Input,
-  A2,
-  E2,
-  R2,
-  I2 extends Input,
-  A3,
-  E3,
-  R3,
-  I3 extends Input
->(
+export const delimited = <A1, E1, R1, I1 extends Input, A2, E2, R2, I2 extends Input, A3, E3, R3, I3 extends Input>(
   open: Parser<A1, E1, R1, I1>,
   parser: Parser<A2, E2, R2, I2>,
   close: Parser<A3, E3, R3, I3>
@@ -1400,12 +1586,16 @@ export const delimited = <
   const s1 = open.step
   const s2 = parser.step
   const s3 = close.step
-  return described((state) => {
-    if (s1(state) === Fail) return Fail
-    const a = s2(state)
-    if (a === Fail) return Fail
-    return s3(state) === Fail ? Fail : a
-  }, parser.name, { _tag: "Seq", parsers: [open, parser, close], output: 1 })
+  return described(
+    (state) => {
+      if (s1(state) === Fail) return Fail
+      const a = s2(state)
+      if (a === Fail) return Fail
+      return s3(state) === Fail ? Fail : a
+    },
+    parser.name,
+    { _tag: "Seq", parsers: [open, parser, close], output: 1 }
+  )
 }
 
 /**
@@ -1415,20 +1605,7 @@ export const delimited = <
  * @since 0.1.0
  * @category sequencing
  */
-export const separatedPair = <
-  A1,
-  E1,
-  R1,
-  I1 extends Input,
-  A2,
-  E2,
-  R2,
-  I2 extends Input,
-  A3,
-  E3,
-  R3,
-  I3 extends Input
->(
+export const separatedPair = <A1, E1, R1, I1 extends Input, A2, E2, R2, I2 extends Input, A3, E3, R3, I3 extends Input>(
   first: Parser<A1, E1, R1, I1>,
   separator: Parser<A2, E2, R2, I2>,
   second: Parser<A3, E3, R3, I3>
@@ -1436,13 +1613,17 @@ export const separatedPair = <
   const s1 = first.step
   const s2 = separator.step
   const s3 = second.step
-  return described((state) => {
-    const a = s1(state)
-    if (a === Fail) return Fail
-    if (s2(state) === Fail) return Fail
-    const b = s3(state)
-    return b === Fail ? Fail : [a, b]
-  }, undefined, { _tag: "Seq", parsers: [first, separator, second], output: [0, 2] })
+  return described(
+    (state) => {
+      const a = s1(state)
+      if (a === Fail) return Fail
+      if (s2(state) === Fail) return Fail
+      const b = s3(state)
+      return b === Fail ? Fail : [a, b]
+    },
+    undefined,
+    { _tag: "Seq", parsers: [first, separator, second], output: [0, 2] }
+  )
 }
 
 /**
@@ -1461,6 +1642,23 @@ export const separatedPair = <
  * })
  * ```
  *
+ * The body runs on every parse, so parsers created inside it, like
+ * `Token.literal("=")` above, are rebuilt on every run. On hot paths, build
+ * them once outside the body:
+ *
+ * ```ts
+ * import { Ascii, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const equals = Token.literal("=")
+ *
+ * const keyValue = Parser.gen(function*() {
+ *   const key = yield* Ascii.alpha1
+ *   yield* equals
+ *   const value = yield* Ascii.decInt
+ *   return [key, value] as const
+ * })
+ * ```
+ *
  * @since 0.1.0
  * @category sequencing
  */
@@ -1498,7 +1696,7 @@ export const gen = <Eff extends Parser.Any, AEff>(
  * @since 0.1.0
  * @category do notation
  */
-export const Do: Parser<{}, never, never, Input> = succeed({})
+export const Do: Parser<Record<never, never>, never, never, Input> = /*#__PURE__*/ succeed({})
 
 /**
  * Binds the output of a parser to a field of the Do record.
@@ -1518,8 +1716,9 @@ export const bind: {
     name: Exclude<N, keyof A>,
     f: (a: NoInfer<A>) => Parser<B, E2, R2, I2>
   ): Parser<Simplify<Omit<A, N> & { [K in N]: B }>, E | E2, R | R2, I & I2>
-} = dual(3, (self: Parser.Any, name: string, f: (a: any) => Parser.Any): Parser.Any =>
-  flatMap(self, (a) => map(f(a), (b) => ({ ...a, [name]: b }))))
+} = /*#__PURE__*/ dual(3, (self: Parser.Any, name: string, f: (a: any) => Parser.Any): Parser.Any =>
+  flatMap(self, (a) => map(f(a), (b) => ({ ...a, [name]: b })))
+)
 
 /**
  * Wraps the output of a parser in a record with a single field.
@@ -1530,7 +1729,7 @@ export const bind: {
 export const bindTo: {
   <N extends string>(name: N): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<{ [K in N]: A }, E, R, I>
   <A, E, R, I extends Input, N extends string>(self: Parser<A, E, R, I>, name: N): Parser<{ [K in N]: A }, E, R, I>
-} = dual(2, (self: Parser.Any, name: string): Parser.Any => map(self, (a) => ({ [name]: a })))
+} = /*#__PURE__*/ dual(2, (self: Parser.Any, name: string): Parser.Any => map(self, (a) => ({ [name]: a })))
 
 const let_: {
   <N extends string, A extends object, B>(
@@ -1542,8 +1741,9 @@ const let_: {
     name: Exclude<N, keyof A>,
     f: (a: NoInfer<A>) => B
   ): Parser<Simplify<Omit<A, N> & { [K in N]: B }>, E, R, I>
-} = dual(3, (self: Parser.Any, name: string, f: (a: any) => unknown): Parser.Any =>
-  map(self, (a) => ({ ...a, [name]: f(a) })))
+} = /*#__PURE__*/ dual(3, (self: Parser.Any, name: string, f: (a: any) => unknown): Parser.Any =>
+  map(self, (a) => ({ ...a, [name]: f(a) }))
+)
 
 export {
   /**
@@ -1582,22 +1782,56 @@ export const alt = <const Ps extends ReadonlyArray<Parser.Any>>(
   const steps = parsers.map((p) => p.step)
   const n = steps.length
   if (n === 0) return reject as any
-  if (n === 1) return parsers[0]!
-  return described((state: State<any>) => {
-    const start = state.pos
-    let failure: Failure | undefined
-    for (let i = 0; i < n; i++) {
-      const a = steps[i]!(state)
-      if (a !== Fail) {
-        if (failure !== undefined && failure.offset === state.pos) state.setHint(failure.offset, failure.expected)
-        return a
+  if (n === 1) return parsers[0]
+  return described(
+    (state: State<any>) => {
+      const start = state.pos
+      // The branches' failures merged left to right, as `mergeFailures` would,
+      // except that the last two failures tied with `failure` wait in `tie1`
+      // and `tie2` and are merged only when needed: when a third tie arrives,
+      // when a succeeding branch stops where they failed (for the hint), or
+      // when the merge is read from the state after `failTies`. An `alt` whose
+      // later branch consumes input discards them unmerged.
+      let failure: Failure | undefined
+      let tie1: Failure | undefined
+      let tie2: Failure | undefined
+      for (let i = 0; i < n; i++) {
+        const a = steps[i](state)
+        if (a !== Fail) {
+          if (failure !== undefined && failure.offset === state.pos) {
+            let expected = failure.expected
+            if (tie1 !== undefined) expected = mergeExpected(expected, tie1.expected)
+            if (tie2 !== undefined) expected = mergeExpected(expected, tie2.expected)
+            state.setHint(failure.offset, expected)
+          }
+          return a
+        }
+        if (state.mode !== "Backtrack") return Fail
+        state.pos = start
+        // The branch's failure, whose own ties (from a nested `alt`) can be taken over unmerged
+        const head = state.failureHead
+        if (failure === undefined || head.offset > failure.offset) {
+          failure = head
+          tie1 = state.failureTie1
+          tie2 = state.failureTie2
+        } else if (head.offset === failure.offset) {
+          const f = state.failure
+          if (tie1 === undefined) tie1 = f
+          else if (tie2 === undefined) tie2 = f
+          else {
+            failure = mergeTiedFailures(failure, tie1, mergeExpected(failure.expected, tie1.expected))
+            tie1 = tie2
+            tie2 = f
+          }
+        }
       }
-      if (state.mode !== "Backtrack") return Fail
-      failure = failure === undefined ? state.failure : mergeFailures(failure, state.failure)
-      state.pos = start
-    }
-    return state.failWith("Backtrack", failure!)
-  }, "alt", { _tag: "Alt", parsers })
+      // `failure` is set: there are at least two alternatives, and each one that fails sets it
+      if (failure === undefined) return state.failWith("Backtrack", state.failure)
+      return tie1 === undefined ? state.failWith("Backtrack", failure) : state.failTies(failure, tie1, tie2)
+    },
+    "alt",
+    { _tag: "Alt", parsers }
+  )
 }
 
 /**
@@ -1609,6 +1843,11 @@ export const alt = <const Ps extends ReadonlyArray<Parser.Any>>(
  * an optional `otherwise` parser for unlisted keys, like winnow's `_ =>`
  * arm), or as a function returning a parser (or `undefined` for no match).
  *
+ * Prefer a record where the keys are known. Compiled code (see the
+ * `Compiler` module) switches on the key and runs every case compiled; the
+ * parser a function returns always runs interpreted, and one the function
+ * builds (`(c) => Parser.cut(p)`) is rebuilt on every run.
+ *
  * @example
  * ```ts
  * import { Ascii, Parser, Token } from "@thomasfosterau/effect-parse"
@@ -1656,26 +1895,31 @@ export const dispatch: {
   cases: ((key: any) => Parser.Any | undefined) | Record<PropertyKey, Parser.Any>,
   otherwise?: Parser.Any
 ) => {
-  const choose = typeof cases === "function" ? cases : (key: PropertyKey) =>
-    Object.prototype.hasOwnProperty.call(cases, key) ? cases[key] : otherwise
+  const choose = Predicate.isFunction(cases)
+    ? cases
+    : (key: PropertyKey) => (Object.prototype.hasOwnProperty.call(cases, key) ? cases[key] : otherwise)
   const step = selector.step
-  return described((state: State<any>) => {
-    const start = state.pos
-    const key = step(state)
-    if (key === Fail) return Fail
-    const parser = choose(key)
-    if (parser === undefined) {
-      state.pos = start
-      return state.backtrack("Dispatch")
+  return described(
+    (state: State<any>) => {
+      const start = state.pos
+      const key = step(state)
+      if (key === Fail) return Fail
+      const parser = choose(key)
+      if (parser === undefined) {
+        state.pos = start
+        return state.backtrack("Dispatch")
+      }
+      return parser.step(state)
+    },
+    "dispatch",
+    {
+      _tag: "Dispatch",
+      selector,
+      cases: Predicate.isFunction(cases) ? undefined : cases,
+      otherwise: Predicate.isFunction(cases) ? undefined : otherwise,
+      choose
     }
-    return parser.step(state)
-  }, "dispatch", {
-    _tag: "Dispatch",
-    selector,
-    cases: typeof cases === "function" ? undefined : cases,
-    otherwise: typeof cases === "function" ? undefined : otherwise,
-    choose
-  })
+  )
 }
 
 /**
@@ -1697,16 +1941,18 @@ export const permutation = <const Ps extends ReadonlyArray<Parser.Any>>(
   const steps = parsers.map((p) => p.step)
   const n = steps.length
   return make((state: State<any>) => {
-    const out = new Array(n)
+    // A round's failures, merged only if no parser matches in it (#44)
+    const ties = new TiedFailures()
     const done = new Array<boolean>(n).fill(false)
+    const out = new Array(n)
     let remaining = n
     while (remaining > 0) {
-      let failure: Failure | undefined
+      ties.clear()
       let matched = false
       for (let i = 0; i < n; i++) {
         if (done[i]) continue
         const start = state.pos
-        const a = steps[i]!(state)
+        const a = steps[i](state)
         if (a !== Fail) {
           out[i] = a
           done[i] = true
@@ -1715,10 +1961,11 @@ export const permutation = <const Ps extends ReadonlyArray<Parser.Any>>(
           break
         }
         if (state.mode !== "Backtrack") return Fail
-        failure = failure === undefined ? state.failure : mergeFailures(failure, state.failure)
         state.pos = start
+        ties.add(state)
       }
-      if (!matched) return state.failWith("Backtrack", failure!)
+      // Some parser is not done yet, and each one that fails is folded in
+      if (!matched) return ties.fail(state)
     }
     return out as any
   }, "permutation")
@@ -1730,7 +1977,7 @@ export const permutation = <const Ps extends ReadonlyArray<Parser.Any>>(
 
 const normalizeRange = (range: Range | undefined): [min: number, max: number] => {
   if (range === undefined) return [0, Infinity]
-  if (typeof range === "number") return [range, range]
+  if (Predicate.isNumber(range)) return [range, range]
   const min = range.min ?? 0
   const max = range.max ?? Infinity
   if (min > max) throw new RangeError(`invalid range: min (${min}) > max (${max})`)
@@ -1757,44 +2004,50 @@ const foldImpl = <A, B, E, R, I extends Input>(
   init: () => B,
   f: (acc: B, a: A) => B,
   name: string,
-  node?: Node
+  node?: Node,
+  cond?: (acc: B) => boolean
 ): Parser<B, E, R, I> => {
   const [min, max] = normalizeRange(range)
   const step = self.step
   const checkLoop = max === Infinity
   const key = {}
-  return described((state) => {
-    const entry = state.pos
-    let acc: B
-    let count = 0
-    const resumed = state.resume === undefined ? undefined : Resume.take(state, key, entry) as FoldCheckpoint<B>
-    if (resumed instanceof Resume.Done) {
-      state.pos = resumed.pos
-      return resumed.value as B
-    }
-    if (resumed !== undefined) {
-      acc = resumed.acc
-      count = resumed.count
-      state.pos = resumed.pos
-    } else {
-      acc = init()
-    }
-    for (; count < max; count++) {
-      const start = state.pos
-      const a = step(state)
-      if (a === Fail) {
-        if (state.mode === "Incomplete" && state.resume !== undefined) {
-          Resume.save(state, key, entry, { acc, count, pos: start } satisfies FoldCheckpoint<B>)
+  return described(
+    (state) => {
+      const entry = state.pos
+      let acc: B
+      let count = 0
+      const resumed = state.resume === undefined ? undefined : (Resume.take(state, key, entry) as FoldCheckpoint<B>)
+      if (resumed instanceof Resume.Done) {
+        state.pos = resumed.pos
+        return resumed.value as B
+      }
+      if (resumed !== undefined) {
+        acc = resumed.acc
+        count = resumed.count
+        state.pos = resumed.pos
+      } else {
+        acc = init()
+      }
+      for (; count < max; count++) {
+        if (cond !== undefined && count >= min && !cond(acc)) break
+        const start = state.pos
+        const a = step(state)
+        if (a === Fail) {
+          if (state.mode === "Incomplete" && state.resume !== undefined) {
+            Resume.save(state, key, entry, { acc, count, pos: start } satisfies FoldCheckpoint<B>)
+          }
+          if (state.mode !== "Backtrack" || count < min) return Fail
+          recover(state, start)
+          return Resume.done(state, key, entry, resumed !== undefined, acc)
         }
-        if (state.mode !== "Backtrack" || count < min) return Fail
-        recover(state, start)
-        return Resume.done(state, key, entry, resumed !== undefined, acc)
+        if (checkLoop && state.pos === start) return assertConsumes(state, name)
+        acc = f(acc, a)
       }
-      if (checkLoop && state.pos === start) return assertConsumes(state, name)
-      acc = f(acc, a)
-    }
-    return Resume.done(state, key, entry, resumed !== undefined, acc)
-  }, name, node ?? { _tag: "Fold", self, init, f, name, ...bounds(range) })
+      return Resume.done(state, key, entry, resumed !== undefined, acc)
+    },
+    name,
+    node ?? { _tag: "Fold", self, init, f, while: cond, name, ...bounds(range) }
+  )
 }
 
 /**
@@ -1828,17 +2081,43 @@ export const repeat: {
     self: Parser<A, E, R, I>,
     range?: Rg
   ): Parser<Repeated<A, Rg>, E, R, I>
-} = dual(isParserArg, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, range?: Range) =>
-  foldImpl<A, Array<A>, E, R, I>(self, range, () => [], (acc, a) => {
-    acc.push(a)
-    return acc
-  }, "repeat", { _tag: "Repeat", self, ...bounds(range) }))
+} = /*#__PURE__*/ dual(isParserArg, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, range?: Range) =>
+  foldImpl<A, Array<A>, E, R, I>(
+    self,
+    range,
+    () => [],
+    (acc, a) => {
+      acc.push(a)
+      return acc
+    },
+    "repeat",
+    { _tag: "Repeat", self, ...bounds(range) }
+  )
+)
 
 /**
  * Applies a parser repeatedly, folding the outputs into an accumulator
  * (winnow's `repeat(..).fold(..)`, nom's `fold_many0`/`fold_many1`/
  * `fold_many_m_n`).
  *
+ * With `while`, the repetition also stops, successfully and without
+ * consuming more input, as soon as the predicate is false of the
+ * accumulator. It is checked before each element once `range.min` elements
+ * have been folded, so `min` still holds.
+ *
+ * @example
+ * ```ts
+ * import { Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * // Keeps the first two digits, leaving the rest unparsed
+ * const two = Parser.fold(Token.oneOf("0123456789"), {
+ *   init: () => "",
+ *   f: (acc, d) => acc + d,
+ *   while: (acc) => acc.length < 2
+ * })
+ * Parser.parsePeek(two, "1234") // Result.succeed(["34", "12"])
+ * ```
+ *
  * @since 0.1.0
  * @category repetition
  */
@@ -1847,17 +2126,29 @@ export const fold: {
     readonly init: () => B
     readonly f: (acc: B, a: A) => B
     readonly range?: Range | undefined
+    readonly while?: ((acc: B) => boolean) | undefined
   }): <E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<B, E, R, I>
-  <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, options: {
-    readonly init: () => B
-    readonly f: (acc: B, a: A) => B
-    readonly range?: Range | undefined
-  }): Parser<B, E, R, I>
-} = dual(2, <A, E, R, I extends Input, B>(self: Parser<A, E, R, I>, options: {
-  readonly init: () => B
-  readonly f: (acc: B, a: A) => B
-  readonly range?: Range | undefined
-}): Parser<B, E, R, I> => foldImpl(self, options.range, options.init, options.f, "fold"))
+  <A, E, R, I extends Input, B>(
+    self: Parser<A, E, R, I>,
+    options: {
+      readonly init: () => B
+      readonly f: (acc: B, a: A) => B
+      readonly range?: Range | undefined
+      readonly while?: ((acc: B) => boolean) | undefined
+    }
+  ): Parser<B, E, R, I>
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B>(
+    self: Parser<A, E, R, I>,
+    options: {
+      readonly init: () => B
+      readonly f: (acc: B, a: A) => B
+      readonly range?: Range | undefined
+      readonly while?: ((acc: B) => boolean) | undefined
+    }
+  ): Parser<B, E, R, I> => foldImpl(self, options.range, options.init, options.f, "fold", undefined, options.while)
+)
 
 /**
  * Applies `self` repeatedly until `end` succeeds, returning the collected
@@ -1871,47 +2162,58 @@ export const repeatTill: {
   <B, E2, R2, I2 extends Input, const Rg extends Range = { readonly min: 0 }>(
     end: Parser<B, E2, R2, I2>,
     range?: Rg
-  ): <A, E, R, I extends Input>(
-    self: Parser<A, E, R, I>
-  ) => Parser<[Repeated<A, Rg>, B], E | E2, R | R2, I & I2>
+  ): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<[Repeated<A, Rg>, B], E | E2, R | R2, I & I2>
   <A, E, R, I extends Input, B, E2, R2, I2 extends Input, const Rg extends Range = { readonly min: 0 }>(
     self: Parser<A, E, R, I>,
     end: Parser<B, E2, R2, I2>,
     range?: Rg
   ): Parser<[Repeated<A, Rg>, B], E | E2, R | R2, I & I2>
-} = dual(isTwoParserArgs, <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
-  self: Parser<A, E, R, I>,
-  end: Parser<B, E2, R2, I2>,
-  range?: Range
-): Parser<[Array<A>, B], E | E2, R | R2, I & I2> => {
-  const [min, max] = normalizeRange(range)
-  const step = self.step
-  const endStep = end.step
-  return described((state) => {
-    const acc: Array<A> = []
-    while (true) {
-      const start = state.pos
-      let endFailure: Failure | undefined
-      if (acc.length >= min) {
-        const b = endStep(state)
-        if (b !== Fail) return [acc, b]
-        if (state.mode !== "Backtrack") return Fail
-        endFailure = state.failure
-        state.pos = start
-        if (acc.length >= max) return Fail
-      }
-      const a = step(state)
-      if (a === Fail) {
-        if (endFailure !== undefined && state.mode === "Backtrack") {
-          state.failWith("Backtrack", mergeFailures(endFailure, state.failure))
+} = /*#__PURE__*/ dual(
+  isTwoParserArgs,
+  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
+    self: Parser<A, E, R, I>,
+    end: Parser<B, E2, R2, I2>,
+    range?: Range
+  ): Parser<[Array<A>, B], E | E2, R | R2, I & I2> => {
+    const [min, max] = normalizeRange(range)
+    const step = self.step
+    const endStep = end.step
+    return described(
+      (state) => {
+        const acc: Array<A> = []
+        while (true) {
+          const start = state.pos
+          let endFailure: Failure | undefined
+          if (acc.length >= min) {
+            const b = endStep(state)
+            if (b !== Fail) return [acc, b]
+            if (state.mode !== "Backtrack") return Fail
+            endFailure = state.failure
+            state.pos = start
+            if (acc.length >= max) return Fail
+          }
+          const a = step(state)
+          if (a === Fail) {
+            if (endFailure !== undefined && state.mode === "Backtrack") {
+              state.failWith("Backtrack", mergeFailures(endFailure, state.failure))
+            }
+            return Fail
+          }
+          if (state.pos === start) return assertConsumes(state, "repeatTill")
+          acc.push(a)
         }
-        return Fail
-      }
-      if (state.pos === start) return assertConsumes(state, "repeatTill")
-      acc.push(a)
-    }
-  }, "repeatTill", { _tag: "RepeatTill", self, end, ...bounds(range) })
-})
+      },
+      "repeatTill",
+      { _tag: "RepeatTill", self, end, ...bounds(range) }
+    )
+  }
+)
+
+/** How far `separated` got: the elements so far, and where the next separator starts. */
+interface SeparatedCheckpoint<A> {
+  readonly acc: Array<A>
+  readonly pos: number
+}
 
 /**
  * Applies `self` repeatedly, separated by `separator`, collecting the
@@ -1929,12 +2231,6 @@ export const repeatTill: {
  * @since 0.1.0
  * @category repetition
  */
-/** How far `separated` got: the elements so far, and where the next separator starts. */
-interface SeparatedCheckpoint<A> {
-  readonly acc: Array<A>
-  readonly pos: number
-}
-
 export const separated: {
   <S, E2, R2, I2 extends Input, const Rg extends Range = { readonly min: 0 }>(
     separator: Parser<S, E2, R2, I2>,
@@ -1945,64 +2241,72 @@ export const separated: {
     separator: Parser<S, E2, R2, I2>,
     range?: Rg
   ): Parser<Repeated<A, Rg>, E | E2, R | R2, I & I2>
-} = dual(isTwoParserArgs, <A, E, R, I extends Input, S, E2, R2, I2 extends Input>(
-  self: Parser<A, E, R, I>,
-  separator: Parser<S, E2, R2, I2>,
-  range?: Range
-): Parser<Array<A>, E | E2, R | R2, I & I2> => {
-  const [min, max] = normalizeRange(range)
-  const step = self.step
-  const sepStep = separator.step
-  const checkLoop = max === Infinity
-  const key = {}
-  return described((state) => {
-    const entry = state.pos
-    let acc: Array<A>
-    const resumed = state.resume === undefined ? undefined : Resume.take(state, key, entry) as SeparatedCheckpoint<A>
-    if (resumed instanceof Resume.Done) {
-      state.pos = resumed.pos
-      return resumed.value as Array<A>
-    }
-    if (resumed !== undefined) {
-      acc = resumed.acc
-      state.pos = resumed.pos
-    } else {
-      acc = []
-      if (max === 0) return acc
-      const start = state.pos
-      const first = step(state)
-      if (first === Fail) {
-        if (state.mode !== "Backtrack" || min > 0) return Fail
-        recover(state, start)
-        return acc
-      }
-      acc.push(first)
-    }
-    while (acc.length < max) {
-      const start = state.pos
-      if (sepStep(state) === Fail) {
-        if (state.mode === "Incomplete" && state.resume !== undefined) {
-          Resume.save(state, key, entry, { acc, pos: start } satisfies SeparatedCheckpoint<A>)
+} = /*#__PURE__*/ dual(
+  isTwoParserArgs,
+  <A, E, R, I extends Input, S, E2, R2, I2 extends Input>(
+    self: Parser<A, E, R, I>,
+    separator: Parser<S, E2, R2, I2>,
+    range?: Range
+  ): Parser<Array<A>, E | E2, R | R2, I & I2> => {
+    const [min, max] = normalizeRange(range)
+    const step = self.step
+    const sepStep = separator.step
+    const checkLoop = max === Infinity
+    const key = {}
+    return described(
+      (state) => {
+        const entry = state.pos
+        let acc: Array<A>
+        const resumed =
+          state.resume === undefined ? undefined : (Resume.take(state, key, entry) as SeparatedCheckpoint<A>)
+        if (resumed instanceof Resume.Done) {
+          state.pos = resumed.pos
+          return resumed.value as Array<A>
         }
-        if (state.mode !== "Backtrack" || acc.length < min) return Fail
-        recover(state, start)
-        return Resume.done(state, key, entry, resumed !== undefined, acc)
-      }
-      if (checkLoop && state.pos === start) return assertConsumes(state, "separated")
-      const a = step(state)
-      if (a === Fail) {
-        if (state.mode === "Incomplete" && state.resume !== undefined) {
-          Resume.save(state, key, entry, { acc, pos: start } satisfies SeparatedCheckpoint<A>)
+        if (resumed !== undefined) {
+          acc = resumed.acc
+          state.pos = resumed.pos
+        } else {
+          acc = []
+          if (max === 0) return acc
+          const start = state.pos
+          const first = step(state)
+          if (first === Fail) {
+            if (state.mode !== "Backtrack" || min > 0) return Fail
+            recover(state, start)
+            return acc
+          }
+          acc.push(first)
+        }
+        while (acc.length < max) {
+          const start = state.pos
+          if (sepStep(state) === Fail) {
+            if (state.mode === "Incomplete" && state.resume !== undefined) {
+              Resume.save(state, key, entry, { acc, pos: start } satisfies SeparatedCheckpoint<A>)
+            }
+            if (state.mode !== "Backtrack" || acc.length < min) return Fail
+            recover(state, start)
+            return Resume.done(state, key, entry, resumed !== undefined, acc)
+          }
+          if (checkLoop && state.pos === start) return assertConsumes(state, "separated")
+          const a = step(state)
+          if (a === Fail) {
+            if (state.mode === "Incomplete" && state.resume !== undefined) {
+              Resume.save(state, key, entry, { acc, pos: start } satisfies SeparatedCheckpoint<A>)
+            }
+            if (state.mode !== "Backtrack" || acc.length < min) return Fail
+            state.pos = start
+            return Resume.done(state, key, entry, resumed !== undefined, acc)
+          }
+          acc.push(a)
         }
-        if (state.mode !== "Backtrack" || acc.length < min) return Fail
-        state.pos = start
         return Resume.done(state, key, entry, resumed !== undefined, acc)
-      }
-      acc.push(a)
-    }
-    return Resume.done(state, key, entry, resumed !== undefined, acc)
-  }, "separated", { _tag: "Separated", self, separator, ...bounds(range) })
-})
+      },
+      "separated",
+      { _tag: "Separated", self, separator, ...bounds(range) }
+    )
+  }
+)
 
 /**
  * Parses one or more `self` separated by `separator`, folding them from the
@@ -2033,41 +2337,45 @@ export const separatedFoldl1 = <A, E, R, I extends Input, S, E2, R2, I2 extends
   const step = self.step
   const sepStep = separator.step
   const key = {}
-  return described((state) => {
-    const entry = state.pos
-    const resumed = state.resume === undefined ? undefined : Resume.take(state, key, entry) as FoldCheckpoint<A>
-    let acc: A | Fail
-    if (resumed instanceof Resume.Done) {
-      state.pos = resumed.pos
-      return resumed.value as A
-    }
-    if (resumed !== undefined) {
-      acc = resumed.acc
-      state.pos = resumed.pos
-    } else {
-      acc = step(state)
-      if (acc === Fail) return Fail
-    }
-    while (true) {
-      const start = state.pos
-      const s = sepStep(state)
-      if (s === Fail) {
-        if (state.mode === "Incomplete" && state.resume !== undefined) saveFold(state, key, entry, acc, start)
-        if (state.mode !== "Backtrack") return Fail
-        recover(state, start)
-        return Resume.done(state, key, entry, resumed !== undefined, acc as A)
+  return described(
+    (state) => {
+      const entry = state.pos
+      const resumed = state.resume === undefined ? undefined : (Resume.take(state, key, entry) as FoldCheckpoint<A>)
+      let acc: A | Fail
+      if (resumed instanceof Resume.Done) {
+        state.pos = resumed.pos
+        return resumed.value as A
       }
-      if (state.pos === start) return assertConsumes(state, "separatedFoldl1")
-      const a = step(state)
-      if (a === Fail) {
-        if (state.mode === "Incomplete" && state.resume !== undefined) saveFold(state, key, entry, acc, start)
-        if (state.mode !== "Backtrack") return Fail
-        state.pos = start
-        return Resume.done(state, key, entry, resumed !== undefined, acc as A)
+      if (resumed !== undefined) {
+        acc = resumed.acc
+        state.pos = resumed.pos
+      } else {
+        acc = step(state)
+        if (acc === Fail) return Fail
       }
-      acc = op(acc, s, a)
-    }
-  }, "separatedFoldl1", { _tag: "SeparatedFold", self, separator, op, right: false })
+      while (true) {
+        const start = state.pos
+        const s = sepStep(state)
+        if (s === Fail) {
+          if (state.mode === "Incomplete" && state.resume !== undefined) saveFold(state, key, entry, acc, start)
+          if (state.mode !== "Backtrack") return Fail
+          recover(state, start)
+          return Resume.done(state, key, entry, resumed !== undefined, acc as A)
+        }
+        if (state.pos === start) return assertConsumes(state, "separatedFoldl1")
+        const a = step(state)
+        if (a === Fail) {
+          if (state.mode === "Incomplete" && state.resume !== undefined) saveFold(state, key, entry, acc, start)
+          if (state.mode !== "Backtrack") return Fail
+          state.pos = start
+          return Resume.done(state, key, entry, resumed !== undefined, acc as A)
+        }
+        acc = op(acc, s, a)
+      }
+    },
+    "separatedFoldl1",
+    { _tag: "SeparatedFold", self, separator, op, right: false }
+  )
 }
 
 /**
@@ -2086,35 +2394,39 @@ export const separatedFoldr1 = <A, E, R, I extends Input, S, E2, R2, I2 extends
 ): Parser<A, E | E2, R | R2, I & I2> => {
   const step = self.step
   const sepStep = separator.step
-  return described((state) => {
-    const first = step(state)
-    if (first === Fail) return Fail
-    const values: Array<A> = [first]
-    const seps: Array<S> = []
-    while (true) {
-      const start = state.pos
-      const s = sepStep(state)
-      if (s === Fail) {
-        if (state.mode !== "Backtrack") return Fail
-        recover(state, start)
-        break
+  return described(
+    (state) => {
+      const first = step(state)
+      if (first === Fail) return Fail
+      const values: Array<A> = [first]
+      const seps: Array<S> = []
+      while (true) {
+        const start = state.pos
+        const s = sepStep(state)
+        if (s === Fail) {
+          if (state.mode !== "Backtrack") return Fail
+          recover(state, start)
+          break
+        }
+        if (state.pos === start) return assertConsumes(state, "separatedFoldr1")
+        const a = step(state)
+        if (a === Fail) {
+          if (state.mode !== "Backtrack") return Fail
+          state.pos = start
+          break
+        }
+        seps.push(s)
+        values.push(a)
       }
-      if (state.pos === start) return assertConsumes(state, "separatedFoldr1")
-      const a = step(state)
-      if (a === Fail) {
-        if (state.mode !== "Backtrack") return Fail
-        state.pos = start
-        break
+      let acc = values[values.length - 1] as A
+      for (let i = seps.length - 1; i >= 0; i--) {
+        acc = op(values[i] as A, seps[i] as S, acc)
       }
-      seps.push(s)
-      values.push(a)
-    }
-    let acc = values[values.length - 1] as A
-    for (let i = seps.length - 1; i >= 0; i--) {
-      acc = op(values[i] as A, seps[i] as S, acc)
-    }
-    return acc
-  }, "separatedFoldr1", { _tag: "SeparatedFold", self, separator, op, right: true })
+      return acc
+    },
+    "separatedFoldr1",
+    { _tag: "SeparatedFold", self, separator, op, right: true }
+  )
 }
 
 // -----------------------------------------------------------------------------
@@ -2173,22 +2485,29 @@ export const provideService: {
     key: Context.Key<Id, S>,
     service: NoInfer<S>
   ): Parser<A, E, Exclude<R, Id>, I>
-} = dual(3, <A, E, R, I extends Input, Id, S>(
-  self: Parser<A, E, R, I>,
-  key: Context.Key<Id, S>,
-  service: S
-): Parser<A, E, Exclude<R, Id>, I> => {
-  const step = self.step
-  return described((state) => {
-    const prev = state.context
-    state.context = Context.add(prev, key, service) as Context.Context<never>
-    try {
-      return step(state)
-    } finally {
-      state.context = prev
-    }
-  }, self.name, { _tag: "Provide", self })
-})
+} = /*#__PURE__*/ dual(
+  3,
+  <A, E, R, I extends Input, Id, S>(
+    self: Parser<A, E, R, I>,
+    key: Context.Key<Id, S>,
+    service: S
+  ): Parser<A, E, Exclude<R, Id>, I> => {
+    const step = self.step
+    return described(
+      (state) => {
+        const prev = state.context
+        state.context = Context.add(prev, key, service) as Context.Context<never>
+        try {
+          return step(state)
+        } finally {
+          state.context = prev
+        }
+      },
+      self.name,
+      { _tag: "Provide", self }
+    )
+  }
+)
 
 /**
  * Provides a context of services to a parser.
@@ -2204,21 +2523,28 @@ export const provide: {
     self: Parser<A, E, R, I>,
     context: Context.Context<R2>
   ): Parser<A, E, Exclude<R, R2>, I>
-} = dual(2, <A, E, R, I extends Input, R2>(
-  self: Parser<A, E, R, I>,
-  context: Context.Context<R2>
-): Parser<A, E, Exclude<R, R2>, I> => {
-  const step = self.step
-  return described((state) => {
-    const prev = state.context
-    state.context = Context.merge(prev, context) as Context.Context<never>
-    try {
-      return step(state)
-    } finally {
-      state.context = prev
-    }
-  }, self.name, { _tag: "Provide", self })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, R2>(
+    self: Parser<A, E, R, I>,
+    context: Context.Context<R2>
+  ): Parser<A, E, Exclude<R, R2>, I> => {
+    const step = self.step
+    return described(
+      (state) => {
+        const prev = state.context
+        state.context = Context.merge(prev, context) as Context.Context<never>
+        try {
+          return step(state)
+        } finally {
+          state.context = prev
+        }
+      },
+      self.name,
+      { _tag: "Provide", self }
+    )
+  }
+)
 
 // -----------------------------------------------------------------------------
 // Error recovery
@@ -2242,25 +2568,33 @@ export const resumeAfter: {
     self: Parser<A, E, R, I>,
     recover: Parser<B, E2, R2, I2>
   ): Parser<Option.Option<A>, E | E2, R | R2, I & I2>
-} = dual(2, <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
-  self: Parser<A, E, R, I>,
-  recover: Parser<B, E2, R2, I2>
-): Parser<Option.Option<A>, E | E2, R | R2, I & I2> => {
-  const step = self.step
-  const recoverStep = recover.step
-  return described((state) => {
-    const start = state.pos
-    const a = step(state)
-    if (a !== Fail) return Option.some(a)
-    if (state.recovered === undefined || state.mode === "Incomplete") return Fail
-    const failure = state.failure
-    const mode = state.mode
-    state.pos = start
-    if (recoverStep(state) === Fail) return state.failWith(mode, failure)
-    state.recovered.push(failure)
-    return Option.none()
-  }, self.name, { _tag: "ResumeAfter", self, recover })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
+    self: Parser<A, E, R, I>,
+    recover: Parser<B, E2, R2, I2>
+  ): Parser<Option.Option<A>, E | E2, R | R2, I & I2> => {
+    const step = self.step
+    const recoverStep = recover.step
+    return described(
+      (state) => {
+        const start = state.pos
+        const a = step(state)
+        if (a !== Fail) return Option.some(a)
+        if (state.recovered === undefined || state.mode === "Incomplete") return Fail
+        const failure = state.failure
+        const mode = state.mode
+        state.pos = start
+        if (recoverStep(state) === Fail) return state.failWith(mode, failure)
+        state.recovered.push(failure)
+        state.syntax?.skipped(start, failure, mode)
+        return Option.none()
+      },
+      self.name,
+      { _tag: "ResumeAfter", self, recover }
+    )
+  }
+)
 
 /**
  * Error recovery: if the parser fails, record the failure, skip input with
@@ -2280,26 +2614,34 @@ export const retryAfter: {
     self: Parser<A, E, R, I>,
     recover: Parser<B, E2, R2, I2>
   ): Parser<A, E | E2, R | R2, I & I2>
-} = dual(2, <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
-  self: Parser<A, E, R, I>,
-  recover: Parser<B, E2, R2, I2>
-): Parser<A, E | E2, R | R2, I & I2> => {
-  const step = self.step
-  const recoverStep = recover.step
-  return described((state) => {
-    while (true) {
-      const start = state.pos
-      const a = step(state)
-      if (a !== Fail) return a
-      if (state.recovered === undefined || state.mode === "Incomplete") return Fail
-      const failure = state.failure
-      const mode = state.mode
-      state.pos = start
-      if (recoverStep(state) === Fail || state.pos === start) return state.failWith(mode, failure)
-      state.recovered.push(failure)
-    }
-  }, self.name, { _tag: "RetryAfter", self, recover })
-})
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R, I extends Input, B, E2, R2, I2 extends Input>(
+    self: Parser<A, E, R, I>,
+    recover: Parser<B, E2, R2, I2>
+  ): Parser<A, E | E2, R | R2, I & I2> => {
+    const step = self.step
+    const recoverStep = recover.step
+    return described(
+      (state) => {
+        while (true) {
+          const start = state.pos
+          const a = step(state)
+          if (a !== Fail) return a
+          if (state.recovered === undefined || state.mode === "Incomplete") return Fail
+          const failure = state.failure
+          const mode = state.mode
+          state.pos = start
+          if (recoverStep(state) === Fail || state.pos === start) return state.failWith(mode, failure)
+          state.recovered.push(failure)
+          state.syntax?.skipped(start, failure, mode)
+        }
+      },
+      self.name,
+      { _tag: "RetryAfter", self, recover }
+    )
+  }
+)
 
 // -----------------------------------------------------------------------------
 // Debugging
@@ -2317,33 +2659,37 @@ export const retryAfter: {
 export const trace: {
   (name: string): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>
   <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I>
-} = dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I> => {
+} = /*#__PURE__*/ dual(2, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, name: string): Parser<A, E, R, I> => {
   const step = self.step
-  return described((state) => {
-    const tracer = state.tracer
-    if (tracer === undefined) return step(state)
-    const start = state.pos
-    const depth = state.depth
-    tracer({ _tag: "Enter", name, depth, offset: start, state })
-    state.depth = depth + 1
-    const a = step(state)
-    state.depth = depth
-    tracer({
-      _tag: "Exit",
-      name,
-      depth,
-      offset: start,
-      endOffset: state.pos,
-      result: a === Fail ? state.mode : "Ok",
-      state
-    })
-    return a
-  }, name, { _tag: "Trace", self, name })
+  return described(
+    (state) => {
+      const tracer = state.tracer
+      if (tracer === undefined) return step(state)
+      const start = state.pos
+      const depth = state.depth
+      tracer({ _tag: "Enter", name, depth, offset: start, state })
+      state.depth = depth + 1
+      const a = step(state)
+      state.depth = depth
+      tracer({
+        _tag: "Exit",
+        name,
+        depth,
+        offset: start,
+        endOffset: state.pos,
+        result: a === Fail ? state.mode : "Ok",
+        state
+      })
+      return a
+    },
+    name,
+    { _tag: "Trace", self, name }
+  )
 })
 
 const preview = (state: State<any>, offset: number): string => {
   const input = state.input
-  if (typeof input === "string") {
+  if (Predicate.isString(input)) {
     const s = input.slice(offset, offset + 24)
     return JSON.stringify(s) + (offset + 24 < input.length ? "…" : "∅")
   }
@@ -2371,88 +2717,28 @@ export const consoleTracer = (event: TraceEvent): void => {
 }
 
 // -----------------------------------------------------------------------------
-// Compilation
+// Compiled parsers
 // -----------------------------------------------------------------------------
 
-/**
- * Options for {@link compile}.
- *
- * @since 0.1.0
- * @category compilation
- */
-export interface CompileOptions {
-  /**
-   * Which compiler to use:
-   *
-   * - `"auto"` (the default): generated code (a JIT) where `new Function`
-   *   is allowed, otherwise specialized closures
-   * - `"closure"`: specialized closures only. It never generates code, so
-   *   it is the choice under a Content Security Policy, where even probing
-   *   for `new Function` is reported as a violation.
-   */
-  readonly backend?: "auto" | "closure" | undefined
-}
-
-/**
- * Compiles a parser into fused, specialized code, and returns the same
- * parser. Grammars are written as usual; compilation only makes
- * {@link parse}, {@link parseSync}, {@link parsePeek} and
- * {@link parseEffect} faster. Compile the root of a grammar once, where it
- * is defined:
- *
- * ```ts
- * import { Ascii, Parser, Token } from "@thomasfosterau/effect-parse"
- *
- * export const list = Parser.compile(
- *   Parser.separated(Ascii.decInt, Token.literal(","))
- * )
- * Parser.parse(list, "1,2,3") // Result.succeed([1, 2, 3]), compiled
- * ```
- *
- * The code is generated lazily on the first run, for each kind of input
- * (string, bytes or array), and cached with the parser.
- *
- * **Results and errors are unchanged.** Compiled code records no
- * diagnostics. When it fails, the parser runs again, interpreted, from the
- * start, so every `ParseError` (offset, expected, context, cause and
- * message) is exactly the one the interpreter reports.
- *
- * **Callbacks should be pure.** On an input that fails, the callbacks given
- * to `map`, `filter`, `tryMap`, `tap`, `fold`, ... may run twice, once
- * compiled and once interpreted. Callbacks whose results are discarded
- * (a `map` inside `taken` or `preceded`, for example) may not run at all,
- * nor those of a branch that is certain to fail, and token-set predicates
- * may be called once per character code and cached.
- *
- * Runs on partial input ({@link parsePartial}, `ParserStream`), with
- * {@link parseRecoverable} or with the `trace` option are always
- * interpreted. Parsers that can't be described, such as {@link make} and
- * {@link gen}, run interpreted inside compiled code.
- *
- * @since 0.1.0
- * @category compilation
- */
-export const compile: {
-  (options?: CompileOptions): <A, E, R, I extends Input>(self: Parser<A, E, R, I>) => Parser<A, E, R, I>
-  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, options?: CompileOptions): Parser<A, E, R, I>
-} = dual(isParserArg, <A, E, R, I extends Input>(self: Parser<A, E, R, I>, options?: CompileOptions) => {
-  Compiler.register(self, options?.backend ?? "auto")
-  return self
-})
-
 /** Returned by {@link runCompiled} when there is no compiled form to run. */
-const NotCompiled: unique symbol = Symbol("NotCompiled")
+const NotCompiled: unique symbol = /*#__PURE__*/ Symbol("NotCompiled")
 
 /**
  * Runs the compiled form of `self`, if it has one: returns its value, or
  * `Fail` when it failed (or, with `whole`, did not consume the whole
- * input), in which case the state must be thrown away.
- */
-const runCompiled = <I extends Input>(self: Parser.Any, state: State<I>, whole: boolean): unknown => {
+ * input), in which case the state must be thrown away. `resumable` selects
+ * the build that handles partial input.
+ */
+const runCompiled = <I extends Input>(
+  self: Parser.Any,
+  state: State<I>,
+  whole: boolean,
+  resumable = false
+): unknown => {
   if (state.tracer !== undefined || state.recovered !== undefined) return NotCompiled
-  const step = Compiler.stepFor(self, state)
+  const step = Registry.stepFor(self, state, resumable)
   if (step === undefined) return NotCompiled
-  const a = step(state)
+  const a = Stack.run(step, state)
   if (a === Fail || (whole && state.pos < state.end)) return Fail
   return a
 }
@@ -2473,6 +2759,19 @@ export interface ParseOptions {
    * {@link consoleTracer}.
    */
   readonly trace?: boolean | ((event: TraceEvent) => void) | undefined
+  /**
+   * Where to start parsing (default `0`): in code units for strings, bytes
+   * for byte input and elements for arrays. The result is that of parsing
+   * `input.slice(offset)`, but without copying the input, and every offset
+   * (`parsePartial`'s `Done`, `location`, spans, `ParseError.offset` and its
+   * line and column) is a position in the whole input. This is what an
+   * incremental driver, such as a lexer reading one token at a time from a
+   * buffer, needs: compiled parsers run compiled from any offset.
+   *
+   * Throws a `RangeError` unless it is an integer from `0` to the input's
+   * length.
+   */
+  readonly offset?: number | undefined
 }
 
 /**
@@ -2490,7 +2789,11 @@ const makeState = <I extends Input>(
   options: (ParseOptions & { readonly context?: Context.Context<any> }) | undefined,
   partial: boolean
 ): State<I> => {
-  const state = new State(input, { partial, context: options?.context })
+  const offset = options?.offset
+  const state = new State(input, { partial, context: options?.context, offset })
+  if (offset !== undefined && !(Number.isInteger(offset) && offset >= 0 && offset <= state.end)) {
+    throw new RangeError(`Invalid offset ${offset} for an input of length ${state.end}`)
+  }
   const t = options?.trace
   if (t !== undefined && t !== false) state.tracer = t === true ? consoleTracer : t
   return state
@@ -2517,7 +2820,7 @@ const runComplete = <A, E, R, I extends Input>(
   self: Parser<A, E, R, I>,
   state: State<I>
 ): Result.Result<A, ParseError.ParseError<E>> => {
-  const a = self.step(state)
+  const a = Stack.run(self.step, state)
   if (a === Fail) return Result.fail(toError(state))
   if (state.pos < state.end) {
     state.backtrack("Eof", expectedEof)
@@ -2567,7 +2870,11 @@ export const parse: {
  */
 export const parseSync: {
   <A, E, I extends Input>(self: Parser<A, E, never, I>, input: NoInfer<Source<I>>, options?: ParseOptions): A
-  <A, E, R, I extends Input>(self: Parser<A, E, R, I>, input: NoInfer<Source<I>>, options: ParseOptionsWithContext<R>): A
+  <A, E, R, I extends Input>(
+    self: Parser<A, E, R, I>,
+    input: NoInfer<Source<I>>,
+    options: ParseOptionsWithContext<R>
+  ): A
 } = <A, E, R, I extends Input>(
   self: Parser<A, E, R, I>,
   input: I | Source<I>,
@@ -2583,6 +2890,10 @@ export const parseSync: {
  * input along with the output, nom-style (winnow's `parse_peek`, nom's
  * `IResult`).
  *
+ * The parser ended at offset `input.length - remaining.length`, which is
+ * how a caller running from an `offset` (see {@link ParseOptions}) finds
+ * where to continue.
+ *
  * @since 0.1.0
  * @category running
  */
@@ -2608,7 +2919,7 @@ export const parsePeek: {
     return Result.succeed([state.slice(state.pos, state.end), compiled as A])
   }
   if (compiled === Fail) state = makeState(input, options, false)
-  const a = self.step(state)
+  const a = Stack.run(self.step, state)
   if (a === Fail) return Result.fail(toError(state))
   return Result.succeed([state.slice(state.pos, state.end), a])
 }
@@ -2633,7 +2944,14 @@ export type PartialResult<A> =
  * of failing or succeeding early.
  *
  * The parser does not have to consume the whole input; the returned
- * `offset` says how much was consumed.
+ * `offset` says where it stopped. It is a position in the whole input, so
+ * with the `offset` option (see {@link ParseOptions}) it is where the next
+ * parse starts.
+ *
+ * A parser compiled with the `Compiler` module runs compiled, with a build
+ * that handles partial input. When it fails or needs more input, it runs again
+ * interpreted, so `Incomplete`'s `needed` and every `ParseError` are the
+ * interpreter's.
  *
  * @example
  * ```ts
@@ -2664,8 +2982,14 @@ export const parsePartial: {
   input: I | Source<I>,
   options?: ParseOptions & { readonly context?: Context.Context<R> }
 ): Result.Result<PartialResult<A>, ParseError.ParseError<E>> => {
-  const state = makeState(input, options, true)
-  const a = self.step(state)
+  let state = makeState(input, options, true)
+  const compiled = runCompiled(self, state, false, true)
+  if (compiled !== NotCompiled && compiled !== Fail) {
+    return Result.succeed({ _tag: "Done", value: compiled as A, offset: state.pos })
+  }
+  // Re-run interpreted for `needed` and the diagnostics
+  if (compiled === Fail) state = makeState(input, options, true)
+  const a = Stack.run(self.step, state)
   if (a !== Fail) return Result.succeed({ _tag: "Done", value: a, offset: state.pos })
   if (state.mode === "Incomplete") {
     const needed = state.failure.needed
@@ -2697,11 +3021,87 @@ export const parseEffect = <A, E, R, I extends Input>(
   input: NoInfer<Source<I>>,
   options?: ParseOptions
 ): Effect.Effect<A, ParseError.ParseError<E>, R> =>
-  Effect.flatMap(
-    Effect.context<R>(),
-    (context) => Effect.fromResult(parseComplete(self, input, { ...options, context }))
+  Effect.flatMap(Effect.context<R>(), (context) =>
+    Effect.fromResult(parseComplete(self, input, { ...options, context }))
   )
 
+/**
+ * Runs a parser on a state you own, from `state.pos`, and returns its output
+ * or {@link Fail}: like calling `self.step(state)`, but using the parser's
+ * compiled form when it has one (see the `Compiler` module). This is the
+ * runner for drivers that make many small runs over one buffer, such as a
+ * lexer reading one token at a time: keep one `Input.State` and
+ * `reset` it (`Input.State.reset`) before each run, and no run allocates a
+ * state, a `Result` or a slice.
+ *
+ * On success the cursor is where the parser stopped. On failure the state
+ * holds the interpreter's failure (`mode`, `failure`, and what
+ * `reportedFailure()` returns): a compiled run that fails is thrown away and
+ * the parser's step runs again from the same position. A partial state
+ * (`partial: true`) runs the compiled build that handles partial input, so
+ * `Incomplete` is reported as the step would report it. Under a tracer,
+ * with recovery on or inside a `Syntax` parse, the step runs interpreted.
+ *
+ * A driver that only needs to know *that* a parser failed (it tries
+ * another, or skips a character) can pass `{ diagnostics: false }` to skip
+ * the interpreted re-run; see {@link RunOptions}.
+ *
+ * Compiled code records no hints or furthest failure when it succeeds, so
+ * a later failure on the same state can list fewer expectations than one
+ * after interpreted runs would: reset the state between runs (as above) and
+ * its errors are the ones {@link parse} reports. Deep nesting fails with an
+ * unrecoverable `TooDeep` failure instead of throwing, as in the other
+ * runners.
+ *
+ * @example
+ * ```ts
+ * import { Ascii, Compiler, Input, Parser, Token } from "@thomasfosterau/effect-parse"
+ *
+ * const token = Compiler.jit(Parser.preceded(Ascii.space0, Parser.alt(Ascii.alpha1, Token.oneOf("+-"))))
+ *
+ * const tokens = (text: string): Array<string> => {
+ *   const state = new Input.State(text)
+ *   const out: Array<string> = []
+ *   while (state.pos < state.end) {
+ *     const t = Parser.run(token, state.reset(state.pos))
+ *     if (t === Input.Fail) break
+ *     out.push(t)
+ *   }
+ *   return out
+ * }
+ *
+ * tokens("a + b") // ["a", "+", "b"]
+ * ```
+ *
+ * @since 0.2.0
+ * @category running
+ */
+export const run = <A, E, R, I extends Input>(
+  self: Parser<A, E, R, I>,
+  state: State<I>,
+  options?: RunOptions
+): A | Fail => Run.runOn(self, self.step, state, options?.diagnostics !== false)
+
+/**
+ * Options for {@link run}.
+ *
+ * @since 0.2.0
+ * @category running
+ */
+export interface RunOptions {
+  /**
+   * Whether a failure records the interpreter's diagnostics (default
+   * `true`). With `false`, a compiled run that fails is not run again
+   * interpreted: the state's `mode` (`Backtrack`, `Cut` or `Incomplete`)
+   * is set and the cursor is back where the run started, but `failure`,
+   * hints and the furthest failure are left as they were. For drivers that
+   * try a parser and move on when it fails, without reporting why, this
+   * halves the cost of each failure. Parsers that run interpreted record
+   * their diagnostics either way.
+   */
+  readonly diagnostics?: boolean | undefined
+}
+
 /**
  * The outcome of {@link parseRecoverable}.
  *