@thomasfosterau/effect-parse 0.5.0 → 0.6.0

package/src/internal/compiler/closure.ts

@@ -19,6 +19,7 @@ import { Defer, nodeOf, scansFloat } from "../node.js"
 import { floatScan, floatTexts, scanFloatBytes, scanFloatString, toFloat } from "../numbers.js"
 import { charOf, fastLimit, firstCodePoint, fold, textIn, utf16be, utf16le, utf8, utf8Text, validate } from "../text.js"
 import { countTokens, indexOf, indexOfAny } from "../tokens.js"
+import { tupleStep } from "../tuple.js"
 import type { AltPlan } from "./first.js"
 import { Key } from "../key.js"
 import * as Resume from "../resume.js"
@@ -527,17 +528,7 @@ class Compiler {
     const steps = node.parsers.map((q, i) => this.compile(q, keep(i)))
     const n = steps.length
     if (!used) return this.chain(steps)
-    if (output === "tuple") {
-      return (s) => {
-        const out = new Array(n)
-        for (let i = 0; i < n; i++) {
-          const a = steps[i](s)
-          if (a === Fail) return Fail
-          out[i] = a
-        }
-        return out
-      }
-    }
+    if (output === "tuple") return tupleStep(steps)
     if (Predicate.isNumber(output)) {
       if (n === 2) {
         const a = steps[0]
@@ -693,7 +684,7 @@ class Compiler {
 
   repeat(node: NodeOf<"Repeat"> | NodeOf<"Fold">, used: boolean): Step {
     const { max, min } = node
-    const checkLoop = max === Infinity
+    // Bounded or not, the repetition checks progress below (#115)
     const isFold = Predicate.isTagged(node, "Fold")
     const cond = isFold ? node.while : undefined
     const c = this.compile(node.self, used)
@@ -740,7 +731,7 @@ class Compiler {
           s.pos = start
           return resumed ? Resume.done(s, key, entry, true, acc) : acc
         }
-        if (checkLoop && s.pos === start) {
+        if (s.pos === start) {
           s.mode = CUT
           return Fail
         }
@@ -812,7 +803,7 @@ class Compiler {
       return true
     }
     const { max, min } = node
-    const checkLoop = max === Infinity
+    // Bounded or not, the repetition checks progress below (#115)
     // A streaming build's checkpoint holds the object built so far (see `repeat`)
     const resumable = this.resumable
     const site = new Key()
@@ -840,7 +831,7 @@ class Compiler {
           if (!ok) {
             return stopEntries(s, site, at, resumed, acc, count, start, min)
           }
-          if (checkLoop && s.pos === start) {
+          if (s.pos === start) {
             s.mode = CUT
             return Fail
           }
@@ -872,7 +863,7 @@ class Compiler {
         if (sep(s) === Fail) {
           return stopEntries(s, site, at, resumed, acc, count, start, min)
         }
-        if (checkLoop && s.pos === start) {
+        if (s.pos === start) {
           s.mode = CUT
           return Fail
         }
@@ -913,7 +904,7 @@ class Compiler {
 
   separated(node: NodeOf<"Separated">, used: boolean): Step {
     const { max, min } = node
-    const checkLoop = max === Infinity
+    // Bounded or not, the repetition checks progress below (#115)
     const c = this.compile(node.self, used)
     const sep = this.compile(node.separator, false)
     const resumable = this.resumable
@@ -961,7 +952,7 @@ class Compiler {
           s.pos = start
           return resumed ? Resume.done(s, key, entry, true, acc) : acc
         }
-        if (checkLoop && s.pos === start) {
+        if (s.pos === start) {
           s.mode = CUT
           return Fail
         }

package/src/internal/compiler/first.ts

@@ -173,6 +173,12 @@ export class FirstSets {
         const f = this.of(node.self)
         return node.from === "Backtrack" ? (f.mode === Unknown ? f : unknown) : f
       }
+      // `not(p)` consumes nothing. Where `p`'s first set rules a unit out, `p`
+      // backtracks there, so `not(p)` succeeds without consuming: Optional
+      // over `p`'s units. On a unit in that set it may also fail, Cut
+      // included, which Optional leaves open. So `seq(not(p), q)` starts
+      // with `p`'s units and `q`'s, and an `alt` can skip it on any other (#84)
+      case "Not":
       case "Opt":
       case "OrElseSucceed": {
         const f = this.of(node.self)

package/src/internal/compiler/graph.ts

@@ -19,7 +19,16 @@ export const isLeaf = (node: Node): boolean =>
   Predicate.isTagged(node, "OneOf") ||
   Predicate.isTagged(node, "TakeWhile")
 
-/** The number of distinct parents of each parser reachable from `root`. */
+/**
+ * How many times each parser reachable from `root` is used: one for every
+ * place a parent mentions it. A parser used twice is generated once, as a
+ * rule the two places call (unless it is small, see {@link isSmall}).
+ *
+ * Uses are counted, not distinct parents: `seq(p, p)` uses `p` twice. When
+ * only parents were counted, such a `p` was inlined at both places, and a
+ * grammar that does it at every level (`p = seq(p, p)`, twenty times over)
+ * compiled to 2^20 copies: 160 MB of source from twenty lines (#122).
+ */
 export const countRefs = (root: ParserLike): WeakMap<ParserLike, number> => {
   const refs = new WeakMap<ParserLike, number>()
   const seen = new WeakSet<ParserLike>()
@@ -27,10 +36,7 @@ export const countRefs = (root: ParserLike): WeakMap<ParserLike, number> => {
   for (let p = stack.pop(); p !== undefined; p = stack.pop()) {
     if (seen.has(p)) continue
     seen.add(p)
-    const counted = new WeakSet<ParserLike>()
     for (const c of children(nodeOf(p))) {
-      if (counted.has(c)) continue
-      counted.add(c)
       refs.set(c, (refs.get(c) ?? 0) + 1)
       stack.push(c)
     }
@@ -38,6 +44,28 @@ export const countRefs = (root: ParserLike): WeakMap<ParserLike, number> => {
   return refs
 }
 
+/**
+ * The most parsers a code-generating compiler inlines for one root. Sharing
+ * is what keeps generated code proportional to the grammar; a grammar that
+ * is itself enormous (a tree of distinct parsers built by a loop, a derived
+ * schema) would still take minutes and gigabytes to generate, so past this
+ * many the compiler gives up and the next one down takes over (the JIT for
+ * WebAssembly, the closure compiler for the JIT), which costs a closure per
+ * parser instead of source text. The largest grammars in this repository
+ * and the libraries built on it inline a few thousand.
+ */
+export const MaxInlined = 100_000
+
+/** Counts a parser a compiler is about to inline, failing the compilation past {@link MaxInlined}. */
+export const countInlined = (inlined: number): number => {
+  if (inlined >= MaxInlined) {
+    throw new RangeError(
+      `effect-parse: the grammar is too large to generate code for (over ${MaxInlined} parsers inlined)`
+    )
+  }
+  return inlined + 1
+}
+
 /** Whether a parser is small enough to inline wherever it is used. */
 export const isSmall = (p: ParserLike): boolean => {
   let budget = 6

package/src/internal/compiler/jit.ts

@@ -45,7 +45,7 @@ import {
 import type { ClosureCompiler, CompiledRoot, Fallback, Step } from "./closure.js"
 import { backend as closureBackend, createClosureCompiler } from "./closure.js"
 import { buildsEntries, pairOf } from "./entries.js"
-import { countRefs, isLeaf, isLetter, isSmall, lowerAscii, selectorOf } from "./graph.js"
+import { countInlined, countRefs, isLeaf, isLetter, isSmall, lowerAscii, selectorOf } from "./graph.js"
 import type { Backend } from "./registry.js"
 import type { First } from "./first.js"
 import { planAlt, Strict } from "./first.js"
@@ -224,6 +224,8 @@ class Emitter {
   readonly functions: Array<string> = []
   private readonly rules = [new Map<ParserLike, string>(), new Map<ParserLike, string>()]
   private readonly refs: WeakMap<ParserLike, number>
+  /** How many parsers have been inlined (see `countInlined`). */
+  private inlined = 0
   private readonly closure: ClosureCompiler
   private next = 0
 
@@ -257,6 +259,18 @@ class Emitter {
     return enc === utf8 ? `(p-${start}>${ShortText}?R.utf8Text($S,${start},p):${text})` : text
   }
 
+  /**
+   * A count or bound as source text. Every number a description contributes
+   * to the generated source is written here, so nothing but a non-negative
+   * integer can reach it: a bound is a `number` only in the types, and a
+   * string written as given would run as code (#121).
+   */
+  num(n: number): string {
+    if (!Number.isSafeInteger(n) || n < 0)
+      throw new TypeError("effect-parse: a compiled bound must be a non-negative integer")
+    return String(n)
+  }
+
   /** A JavaScript literal for simple values, otherwise a constant. */
   lit(value: unknown): string {
     if (value === undefined) return "void 0"
@@ -401,16 +415,16 @@ class Emitter {
 
   private arrayOneOf(node: NodeOf<"OneOf">, out: string | null, fail: string): string {
     const m = this.const(compileAny(node.set).forCode.token)
-    return `if(p>=E||${m}(I[p])===${node.negate}){${BT}${fail}}${out === null ? "" : `${out}=I[p];`}p++;`
+    return `if(p>=E||${m}(I[p])===${node.negate === true}){${BT}${fail}}${out === null ? "" : `${out}=I[p];`}p++;`
   }
 
   private arrayTakeWhile(node: NodeOf<"TakeWhile">, out: string | null, fail: string, fn: Fn): string {
     const m = this.const(compileAny(node.set).forCode.token)
     const st = this.v(fn)
-    const max = node.max === Infinity ? "" : `&&p-${st}<${node.max}`
+    const max = node.max === Infinity ? "" : `&&p-${st}<${this.num(node.max)}`
     return (
-      `${st}=p;while(p<E${max}&&${m}(I[p])!==${node.negate})p++;` +
-      (node.min > 0 ? `if(p-${st}<${node.min}){${BT}${fail}}` : "") +
+      `${st}=p;while(p<E${max}&&${m}(I[p])!==${node.negate === true})p++;` +
+      (node.min > 0 ? `if(p-${st}<${this.num(node.min)}){${BT}${fail}}` : "") +
       (out === null ? "" : `${out}=I.slice(${st},p);`)
     )
   }
@@ -432,6 +446,7 @@ class Emitter {
   }
 
   inline(p: ParserLike, used: boolean, out: string | null, fail: string, fn: Fn, depth: number): string {
+    this.inlined = countInlined(this.inlined)
     const node = nodeOf(p)
     const set = (value: string) => (out === null ? "" : `${out}=${value};`)
     const d = depth + 1
@@ -654,7 +669,7 @@ class Emitter {
         // On bytes, read inline; at the end of the input, the step reports it
         if (this.kind !== 1) return this.delegate(p, used, out, fail, fn)
         const read = used ? `${out ?? this.v(fn)}=${this.const(node.read)}(I,p,$S);` : ""
-        return `if(E-p>=${node.size}){${read}p+=${node.size}}else{${this.delegate(p, used, out, fail, fn)}}`
+        return `if(E-p>=${this.num(node.size)}){${read}p+=${this.num(node.size)}}else{${this.delegate(p, used, out, fail, fn)}}`
       }
       default:
         return this.delegate(p, used, out, fail, fn)
@@ -891,8 +906,8 @@ class Emitter {
         add = `${acc}.push(${x});`
       }
     }
-    const check = max === Infinity ? `if(p===${st}){$S.mode="Cut";${fail}}` : ""
-    const bound = max === Infinity ? "" : `${n}<${max}`
+    const check = `if(p===${st}){$S.mode="Cut";${fail}}`
+    const bound = max === Infinity ? "" : `${n}<${this.num(max)}`
     const r = this.resumable ? this.resumePoint(fn) : undefined
     // A checkpoint holds the result so far: the accumulator, or what `collect` builds
     const held = collect?.value ?? acc
@@ -906,11 +921,13 @@ class Emitter {
         ? `${this.gen(node.self, tracked, x, `break ${bad};`, fn, d)}${check}${add}`
         : collect.element(`break ${bad};`, check)
     const stop =
-      cond === undefined ? "" : `if(${min > 0 ? `${n}>=${min}&&` : ""}!${this.const(cond)}(${acc}))break ${loop};`
+      cond === undefined
+        ? ""
+        : `if(${min > 0 ? `${n}>=${this.num(min)}&&` : ""}!${this.const(cond)}(${acc}))break ${loop};`
     const body =
       `${loop}:for(;${bound};${n}++){${stop}${st}=p;` +
       `${bad}:{${element}continue ${loop};}` +
-      `${save}if($S.mode!=="Backtrack"${min > 0 ? `||${n}<${min}` : ""}){${fail}}p=${st};break ${loop};}`
+      `${save}if($S.mode!=="Backtrack"${min > 0 ? `||${n}<${this.num(min)}` : ""}){${fail}}p=${st};break ${loop};}`
     if (r === undefined) return `${init}${n}=0;${body}${collect?.finish ?? ""}`
     return r.wrap(
       held,
@@ -980,15 +997,15 @@ class Emitter {
     const self = (f: string) =>
       collect === undefined ? this.gen(node.self, keep, x, f, fn, d) : collect.element(f, "")
     const sep = (f: string) => this.gen(node.separator, false, null, f, fn, d)
-    const check = max === Infinity ? `if(p===${st}){$S.mode="Cut";${fail}}` : ""
+    const check = `if(p===${st}){$S.mode="Cut";${fail}}`
     const first =
       `${collect?.init ?? (keep ? `${acc}=[];` : "")}${n}=0;${st}=p;` +
       attempt(self, `${push}${n}++;`, min > 0 ? "||true" : "", "")
     const rest =
-      `${loop}:while(${max === Infinity ? "true" : `${n}<${max}`}){${st}=p;` +
-      attempt(sep, "", `||${n}<${min}`, save) +
+      `${loop}:while(${max === Infinity ? "true" : `${n}<${this.num(max)}`}){${st}=p;` +
+      attempt(sep, "", `||${n}<${this.num(min)}`, save) +
       check +
-      attempt(self, `${push}${n}++;continue ${loop};`, `||${n}<${min}`, save) +
+      attempt(self, `${push}${n}++;continue ${loop};`, `||${n}<${this.num(min)}`, save) +
       `}`
     if (r === undefined) return `${done}:{${first}${rest}}${collect?.finish ?? ""}`
     // `done` ends the repetition; the checkpoint wrapper records the result after it
@@ -1233,10 +1250,11 @@ class Emitter {
     const loop = this.label()
     const counted = max !== Infinity || min > 1
     const count = counted ? `${n}++;` : ""
-    const bound = max !== Infinity ? `&&${n}<${max}` : ""
+    const bound = max !== Infinity ? `&&${n}<${this.num(max)}` : ""
     const slice = enc !== undefined ? this.text(enc, st) : kind === 0 ? `I.slice(${st},p)` : `I.subarray(${st},p)`
     const finish =
-      (min > 0 ? `if(${counted ? n : `p-${st}`}<${min}){${BT}${fail}}` : "") + (out === null ? "" : `${out}=${slice};`)
+      (min > 0 ? `if(${counted ? n : `p-${st}`}<${this.num(min)}){${BT}${fail}}` : "") +
+      (out === null ? "" : `${out}=${slice};`)
     const head = `${st}=p;${counted ? `${n}=0;` : ""}${loop}:while(p<E${bound}){${c}=${this.unit("p")};`
     const member = this.member(accept, c)
     if (kind === 1 && (enc === undefined || fastLimit(enc) >= TableSize)) {
@@ -1338,7 +1356,9 @@ class Emitter {
       : `if(p!==${b}){${acc}+=${x};continue ${loop}}`
     const slice = enc !== undefined ? this.text(enc, st) : this.kind === 0 ? `I.slice(${st},p)` : `I.subarray(${st},p)`
     const ctrlTest =
-      rd === undefined ? `p<E&&${this.unit("p")}===${ctrl}` : `${rd.guard("p")}&&${rd.unit("p")}===${ctrl}`
+      rd === undefined
+        ? `p<E&&${this.unit("p")}===${this.num(ctrl)}`
+        : `${rd.guard("p")}&&${rd.unit("p")}===${this.num(ctrl)}`
     // In a resumable build, running out of a partial input (not stopping
     // before a non-control character) leaves the text incomplete
     const stop = r === undefined ? loop : this.label()

package/src/internal/compiler/wasm.ts

@@ -35,7 +35,7 @@ import { charOf, fastLimit, latin1, string, utf16be, utf16le, utf8 } from "../te
 import type { Fallback, Step } from "./closure.js"
 import { backend as jitBackend, jitSupported } from "./jit.js"
 import { buildsEntries, isDiagnostic, pairOf } from "./entries.js"
-import { countRefs, isLeaf, isLetter, isSmall, lowerAscii, selectorOf } from "./graph.js"
+import { countInlined, countRefs, isLeaf, isLetter, isSmall, lowerAscii, selectorOf } from "./graph.js"
 import type { Backend, Compiled } from "./registry.js"
 import type { CharSet } from "./sets.js"
 import { kindOfEncoding, TableSize, textSet, tokenSet } from "./sets.js"
@@ -80,6 +80,32 @@ const MaxWrites = 4096
 
 /** Bytes left after the cursor beyond which a driver's parse of the same buffer runs the JIT (see `run`). */
 const LargeRest = 4096
+/**
+ * The most linear memory a module is grown to: 2 GiB. Every offset into the
+ * memory, the trace's included, is then a non-negative `i32`. A parse that
+ * would need more (its input copied, and four to seven times as much of
+ * trace), or whose `memory.grow` the engine refuses, runs on the JIT, which
+ * needs neither (#123).
+ */
+const MaxMemory = 2 ** 31
+/**
+ * Above this much linear memory after a parse (128 MiB), the module is
+ * given a new memory: `WebAssembly.Memory` never shrinks, so one large
+ * input would otherwise hold five to ten times its size for the life of
+ * the process, per compiled parser and input kind.
+ */
+const ReleaseAbove = 128 * 1024 * 1024
+/** What `grow` throws when the trace cannot grow: the parse starts again on the JIT. */
+class MemoryExhausted {}
+/**
+ * A repetition bound as the `i32` it is compared with, unsigned. A count
+ * never reaches 2^32 - 1 (the input is in a 32-bit memory), so a larger
+ * minimum is one that cannot be met, and a larger maximum is none at all
+ * (see `unbounded`); written as given, it was truncated to its low 32 bits.
+ */
+const bound = (n: number): number => (n >= 0xffffffff ? 0xffffffff : n)
+/** Whether a maximum can never be reached by a count (see {@link bound}). */
+const unbounded = (max: number): boolean => max >= 0xffffffff
 
 /** The most literals a compiled `takeUntilAny` checks at each candidate; more are searched in JavaScript. */
 const MaxUntil = 64
@@ -372,6 +398,8 @@ class WasmCompiler {
   private readonly rules = [new WeakMap<ParserLike, number>(), new WeakMap<ParserLike, number>()]
   private readonly pending: Array<readonly [ParserLike, boolean, number]> = []
   private refs = new WeakMap<ParserLike, number>()
+  /** How many parsers have been inlined (see `countInlined`). */
+  private inlined = 0
   private readonly decoders = new WeakMap<Encoding<any>, number>()
   private readonly floatScanners = new WeakMap<Encoding<any>, number>()
   /** The float scanner of `Token` / `Ascii` text, which has no encoding. */
@@ -662,6 +690,7 @@ class WasmCompiler {
   }
 
   inline(p: ParserLike, out: string, b: Body, fail: Label, bf: Vars, depth: number): string {
+    this.inlined = countInlined(this.inlined)
     const node = nodeOf(p)
     const s: Site = { p, out, b, fail, bf, d: depth + 1 }
     const families: ReadonlyArray<(node: Node, s: Site) => Option.Option<string>> = [
@@ -1257,7 +1286,7 @@ class WasmCompiler {
   private stop(b: Body, fail: Label, n: number, min: number, restore: () => void, done: Label): void {
     this.unlessBacktrack(b, fail)
     if (min > 0) {
-      b.get(n).i32(min).op(Op.i32LtU)
+      b.get(n).i32(bound(min)).op(Op.i32LtU)
       b.if(() => b.br(fail))
     }
     restore()
@@ -1299,13 +1328,13 @@ class WasmCompiler {
     b.i32(0).set(n)
     b.block((done) => {
       this.loop(b, (again) => {
-        if (max !== Infinity) b.get(n).i32(max).op(Op.i32GeU).brIf(done)
+        if (!unbounded(max)) b.get(n).i32(bound(max)).op(Op.i32GeU).brIf(done)
         const saved = this.save(b)
         this.attempt(
           b,
           (bad) => {
             elementCode = element(b, bad, bf)
-            if (max === Infinity) this.progress(b, fail, saved[0])
+            this.progress(b, fail, saved[0])
             this.nextElement(b, n, again)
           },
           () => this.stop(b, fail, n, min, () => this.restore(b, saved), done)
@@ -1366,14 +1395,14 @@ class WasmCompiler {
         }
       )
       this.loop(b, (again) => {
-        if (max !== Infinity) b.get(n).i32(max).op(Op.i32GeU).brIf(done)
+        if (!unbounded(max)) b.get(n).i32(bound(max)).op(Op.i32GeU).brIf(done)
         mark()
         this.attempt(
           b,
           (bad) => this.gen(node.separator, "", b, bad, bf, d),
           () => this.stop(b, fail, n, min, back, done)
         )
-        if (max === Infinity) this.progress(b, fail, st)
+        this.progress(b, fail, st)
         this.attempt(
           b,
           (bad) => {
@@ -1673,14 +1702,14 @@ class WasmCompiler {
       b.loop((again) => {
         this.atEnd(b, 0)
         b.brIf(stop)
-        if (max !== Infinity) b.get(n).i32(max).op(Op.i32GeU).brIf(stop)
+        if (!unbounded(max)) b.get(n).i32(bound(max)).op(Op.i32GeU).brIf(stop)
         this.whileStep(enc, b, set, w, wide, stop)
         if (counted) b.get(n).i32(1).op(Op.i32Add).set(n)
         b.br(again)
       })
     })
     if (min > 0) {
-      if (counted) b.get(n).i32(min).op(Op.i32LtU)
+      if (counted) b.get(n).i32(bound(min)).op(Op.i32LtU)
       else b.get(0).get(st).op(Op.i32Eq)
       this.failIf(b, s.fail)
     }
@@ -3004,6 +3033,13 @@ const compileWasm = (root: ParserLike, kind: 0 | 1): Result.Result<Compiled, str
   return run(root, c, bytes, kind, build, source)
 }
 
+/** What a parse calls in an instance of a module: its functions are typed by the module's own type section. */
+interface Entries {
+  readonly widen: Function
+  readonly start: Function
+  readonly mode: WebAssembly.Global
+}
+
 /** A global of a module's exports. */
 const exportedGlobal = (exports: WebAssembly.Exports, name: string): Result.Result<WebAssembly.Global, string> => {
   const g = exports[name]
@@ -3018,7 +3054,7 @@ const run = (
   build: Builder,
   source: string
 ): Result.Result<Compiled, string> => {
-  const memory = new WebAssembly.Memory({ initial: 2 })
+  let memory = new WebAssembly.Memory({ initial: 2 })
   // `memory.buffer` is slow to read: its size, as of the latest growth
   let size = memory.buffer.byteLength
   let i32 = new Int32Array(memory.buffer)
@@ -3029,13 +3065,21 @@ const run = (
     f64 = new Float64Array(memory.buffer)
     u8 = new Uint8Array(memory.buffer)
   }
-  /** Grows the memory to at least `bytes`, doubling it. */
-  const reserve = (bytes: number) => {
+  /**
+   * Grows the memory to at least `bytes`, doubling it: false when that is
+   * more than {@link MaxMemory}, or more than the engine will give.
+   */
+  const reserve = (bytes: number): boolean => {
     const have = size
-    if (have >= bytes) return
-    memory.grow(Math.ceil((Math.max(bytes, have * 2) - have) / PageSize))
+    if (have >= bytes) return true
+    if (bytes > MaxMemory) return false
+    const pages = Math.ceil((Math.min(Math.max(bytes, have * 2), MaxMemory) - have) / PageSize)
+    // `grow` throws a `RangeError` when the engine cannot allocate the pages
+    const grown = Result.try(() => memory.grow(pages))
+    if (Result.isFailure(grown)) return false
     size = memory.buffer.byteLength
     views()
+    return true
   }
   const steps: Array<Step> = c.islands.map(({ parser }) => jitBackend.build(parser, kind, false).step ?? parser.step)
   const used = c.islands.map(({ used }) => used)
@@ -3043,58 +3087,59 @@ const run = (
   const checks = c.checks
   let state: State<any> = idle
   const values: Array<Value> = []
-  const imports = {
-    env: {
-      mem: memory,
-      island: (id: number, pos: number): number => {
-        const s = state
-        s.pos = pos
-        const a = steps[id](s)
-        if (a === Fail) return s.mode === "Cut" ? -2 : -1
-        if (used[id]) values.push(a)
-        return s.pos
-      },
-      // Doubles the memory, returning the new limit of the trace
-      grow: (): number => {
-        reserve(size * 2)
-        // The views changed
-        build.bind(i32, f64, state.input, state.end, values, state)
-        return size - Slack
-      },
-      test: (id: number, cp: number): number => tests[id](cp),
-      // A value island: the value of its parser, built from its trace at `from`, and the callback
-      check: (id: number, from: number): number => {
-        const s = state
-        const a = checks[id](build.value(id, from >> 2))
-        if (a === Fail) {
-          s.mode = "Backtrack"
-          return 0
-        }
-        values.push(a)
-        return 1
-      },
-      // The value of the float text at `[start, end)`, which is ASCII: one byte each, or a
-      // byte and a zero byte in UTF-16
-      float: (start: number, end: number): number => {
-        const input: string | Uint8Array = state.input
-        return toFloat(
-          Predicate.isString(input) ? input.slice(start, end) : latin1.text(input, start, end).replace(/\0/g, "")
-        )
+  const env = {
+    island: (id: number, pos: number): number => {
+      const s = state
+      s.pos = pos
+      const a = steps[id](s)
+      if (a === Fail) return s.mode === "Cut" ? -2 : -1
+      if (used[id]) values.push(a)
+      return s.pos
+    },
+    // Doubles the memory, returning the new limit of the trace
+    grow: (): number => {
+      if (size >= MaxMemory || !reserve(Math.min(size * 2, MaxMemory))) throw new MemoryExhausted()
+      // The views changed
+      build.bind(i32, f64, state.input, state.end, values, state)
+      return size - Slack
+    },
+    test: (id: number, cp: number): number => tests[id](cp),
+    // A value island: the value of its parser, built from its trace at `from`, and the callback
+    check: (id: number, from: number): number => {
+      const s = state
+      // `from` is a byte offset below 2 GiB (`MaxMemory`); unsigned all the same, were it ever not
+      const a = checks[id](build.value(id, from >>> 2))
+      if (a === Fail) {
+        s.mode = "Backtrack"
+        return 0
       }
+      values.push(a)
+      return 1
+    },
+    // The value of the float text at `[start, end)`, which is ASCII: one byte each, or a
+    // byte and a zero byte in UTF-16
+    float: (start: number, end: number): number => {
+      const input: string | Uint8Array = state.input
+      return toFloat(
+        Predicate.isString(input) ? input.slice(start, end) : latin1.text(input, start, end).replace(/\0/g, "")
+      )
     }
   }
-  const instance = new WebAssembly.Instance(new WebAssembly.Module(bytes), imports)
-  const exported = instance.exports
-  const rootFn = exported.root
-  if (!Predicate.isFunction(rootFn)) return Result.fail("no root function")
-  const widenFn = kind === 0 ? exported.widen : rootFn
-  if (!Predicate.isFunction(widenFn)) return Result.fail("no widen function")
-  const startFn = exported.start
-  if (!Predicate.isFunction(startFn)) return Result.fail("no start function")
-  const names = ["mode"] as const
-  const globals = Result.all(names.map((name) => exportedGlobal(exported, name)))
-  if (Result.isFailure(globals)) return Result.fail(globals.failure)
-  const [mode] = globals.success
+  const module = new WebAssembly.Module(bytes)
+  /** The entry points of an instance of the module over `mem`. */
+  const instantiate = (mem: WebAssembly.Memory): Result.Result<Entries, string> => {
+    const exported = new WebAssembly.Instance(module, { env: { ...env, mem } }).exports
+    const rootFn = exported.root
+    if (!Predicate.isFunction(rootFn)) return Result.fail("no root function")
+    const widenFn = kind === 0 ? exported.widen : rootFn
+    if (!Predicate.isFunction(widenFn)) return Result.fail("no widen function")
+    const startFn = exported.start
+    if (!Predicate.isFunction(startFn)) return Result.fail("no start function")
+    return Result.map(exportedGlobal(exported, "mode"), (mode) => ({ widen: widenFn, start: startFn, mode }))
+  }
+  const first = instantiate(memory)
+  if (Result.isFailure(first)) return Result.fail(first.failure)
+  let entries = first.success
   let busy = false
   /** The JIT's step for the parser, built on first use. */
   let fallback: Step = (s) => {
@@ -3110,7 +3155,7 @@ const run = (
    */
   const copyString = (input: string, staging: number) => {
     const { written } = utf8Encoder.encodeInto(input, u8.subarray(staging, staging + 3 * input.length))
-    const replaced: number = widenFn(staging, written)
+    const replaced: number = entries.widen(staging, written)
     if (replaced === 0) return
     // U+FFFD in the string, or a lone surrogate that `encodeInto` replaced by it: its unit, as it is
     const view = new DataView(memory.buffer)
@@ -3128,7 +3173,9 @@ const run = (
     const inputBytes = kind === 0 ? 2 * n : n
     const traceStart = (Input + inputBytes + 15) & -16
     // Strings are staged where the trace goes: 3 bytes of UTF-8 and 4 of list at most per unit
-    reserve(traceStart + Math.max(Slack * 4, inputBytes * 4, kind === 0 ? 7 * n + 16 : 0))
+    if (!reserve(traceStart + Math.max(Slack * 4, inputBytes * 4, kind === 0 ? 7 * n + 16 : 0))) {
+      throw new MemoryExhausted()
+    }
     if (Predicate.isString(input)) {
       // Strings never change: one already in memory (parsed again, or from another offset) stays there
       if (input !== copied) {
@@ -3143,13 +3190,30 @@ const run = (
     values.length = 0
     state = s
     build.bind(i32, f64, input, s.end, values, s)
-    const r: number = startFn(s.pos, s.end, n, traceStart, size - Slack)
+    const r: number = entries.start(s.pos, s.end, n, traceStart, size - Slack)
     if (r < 0) {
-      s.mode = mode.value === Cut ? "Cut" : "Backtrack"
+      s.mode = entries.mode.value === Cut ? "Cut" : "Backtrack"
       return Fail
     }
     s.pos = r
-    return build.root(traceStart >> 2)
+    return build.root(traceStart >>> 2)
+  }
+  /**
+   * Gives the module a new memory of the initial size, dropping the one a
+   * large parse grew (and the string it held). An instance is bound to its
+   * memory, so the module is instantiated again; its data segments fill
+   * the tables in.
+   */
+  const release = () => {
+    const fresh = new WebAssembly.Memory({ initial: 2 })
+    const next = instantiate(fresh)
+    // The module instantiated once already, with these imports; were it to fail, the grown memory stays
+    if (Result.isFailure(next)) return
+    memory = fresh
+    size = fresh.buffer.byteLength
+    views()
+    copied = ""
+    entries = next.success
   }
   /** The bytes copied by the latest parse: parsing them again from further on is a driver at work. */
   let lastBytes: Uint8Array = new Uint8Array(0)
@@ -3170,13 +3234,22 @@ const run = (
     busy = true
     // Whatever happens (a callback may throw), the next parse starts afresh
     pending = s
+    const from = s.pos
     const result = Result.try(parsePending)
     build.unbind()
     state = idle
     pending = idle
     busy = false
     values.length = 0
-    if (Result.isFailure(result)) throw result.failure
+    if (size > ReleaseAbove) release()
+    if (Result.isFailure(result)) {
+      // The input, or its trace, needs more memory than there is: the JIT parses it in place
+      if (result.failure instanceof MemoryExhausted) {
+        s.pos = from
+        return fallback(s)
+      }
+      throw result.failure
+    }
     return result.success
   }
   return Result.succeed({ backend: "wasm", step, guarded: false, fallbacks: c.fallbacks, error: undefined, source })