envio 3.11.0 → 3.12.0

package/src/Rollback.res.mjs

@@ -1,9 +1,9 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "./Utils.res.mjs";
-import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Writing from "./Writing.res.mjs";
+import * as ChainMap from "./ChainMap.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
@@ -44,7 +44,8 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
   await Writing.flush(state);
   let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber);
   let rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
-  let next = Config.isIsolatedMultichain(IndexerState.config(state)) ? RollbackFloors.isolated(reorgChain, rollbackTargetCheckpointId, rollbackTargetBlockNumber) : RollbackFloors.global(rollbackTargetCheckpointId, reorgChain, rollbackTargetBlockNumber);
+  let config = IndexerState.config(state);
+  let next = RollbackFloors.make(config.checkpointSequence, ChainMap.keys(config.chainMap), reorgChain, rollbackTargetCheckpointId, rollbackTargetBlockNumber);
   let match = IndexerState.pendingRollback(state);
   let floors = match !== undefined ? RollbackFloors.merge(match.floors, next) : next;
   let progressDiffByChain = {};
@@ -85,6 +86,7 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
       rolledBackChains.push({
         chainId: chainId,
         progressBlockNumber: toBlock,
+        progressBlockTime: ChainState.committedProgressBlockTime(cs),
         sourceBlockNumber: ChainState.knownHeight(cs),
         totalEventsProcessed: ChainState.numEventsProcessed(cs)
       });
@@ -97,7 +99,7 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
       });
     }
   });
-  let diff$1 = await InMemoryStore.prepareRollbackDiff(state, floors, IndexerState.committedCheckpointId(state) + 1n, rolledBackChains, rolledBackAddresses);
+  let diff$1 = await InMemoryStore.prepareRollbackDiff(state, floors, rolledBackChains, rolledBackAddresses);
   Logging.childTrace(logger, {
     msg: "Rollback entity changes",
     deleted: diff$1.deletedEntities,

package/src/Sink.res

@@ -2,12 +2,13 @@ type t = {
   name: string,
   initialize: (~entities: array<Internal.entityConfig>) => promise<unit>,
   resume: (
-    ~checkpointId: Internal.checkpointId,
+    ~frontier: Frontier.t,
     ~chains: array<Persistence.initialChainState>,
     ~entities: array<Internal.entityConfig>,
   ) => promise<unit>,
   writeBatch: (
     ~batch: Batch.t,
+    ~diffCheckpoints: array<InternalTable.Checkpoints.diffCheckpoint>,
     ~updatedEntities: array<Persistence.updatedEntity>,
   ) => promise<unit>,
 }
@@ -17,6 +18,7 @@ let makeClickHouse = (
   ~database,
   ~username,
   ~password,
+  ~sequence: CheckpointSequence.t,
   ~chainIdMode: ChainId.mode=Int32,
 ): t => {
   let sink = ClickHouse.makeSink(~host, ~username, ~password, ~database, ~chainIdMode)
@@ -29,10 +31,10 @@ let makeClickHouse = (
     initialize: (~entities) => {
       ClickHouse.initialize(sink, ~entities=mirrored(entities))
     },
-    resume: (~checkpointId, ~chains, ~entities) => {
-      ClickHouse.resume(sink, ~checkpointId, ~chains, ~entities=mirrored(entities))
+    resume: (~frontier, ~chains, ~entities) => {
+      ClickHouse.resume(sink, ~sequence, ~frontier, ~chains, ~entities=mirrored(entities))
     },
-    writeBatch: async (~batch, ~updatedEntities) => {
+    writeBatch: async (~batch, ~diffCheckpoints, ~updatedEntities) => {
       // Staging reads JS values, so it holds the isolate and runs here. The
       // encode and the round trips happen in Rust, which also keeps the
       // checkpoints behind the rows they cover.
@@ -44,7 +46,7 @@ let makeClickHouse = (
           | None => ()
           }
         )
-        ClickHouse.stageCheckpointsOrThrow(sink, ~registry, ~batch)
+        ClickHouse.stageCheckpointsOrThrow(sink, ~registry, ~batch, ~diffCheckpoints)
       } catch {
       | exn =>
         sink->ClickHouseSink.discard(entities)

package/src/Sink.res.mjs

@@ -2,7 +2,7 @@
 
 import * as ClickHouse from "./bindings/ClickHouse.res.mjs";
 
-function makeClickHouse(host, database, username, password, chainIdModeOpt) {
+function makeClickHouse(host, database, username, password, sequence, chainIdModeOpt) {
   let chainIdMode = chainIdModeOpt !== undefined ? chainIdModeOpt : "int32";
   let sink = ClickHouse.makeSink(host, username, password, database, chainIdMode);
   let registry = ClickHouse.makeRegistry();
@@ -10,8 +10,8 @@ function makeClickHouse(host, database, username, password, chainIdModeOpt) {
   return {
     name: "clickhouse",
     initialize: entities => ClickHouse.initialize(sink, mirrored(entities)),
-    resume: (checkpointId, chains, entities) => ClickHouse.resume(sink, checkpointId, chains, mirrored(entities)),
-    writeBatch: async (batch, updatedEntities) => {
+    resume: (frontier, chains, entities) => ClickHouse.resume(sink, sequence, frontier, chains, mirrored(entities)),
+    writeBatch: async (batch, diffCheckpoints, updatedEntities) => {
       let entities = [];
       let checkpoints;
       try {
@@ -22,7 +22,7 @@ function makeClickHouse(host, database, username, password, chainIdModeOpt) {
             return;
           }
         });
-        checkpoints = ClickHouse.stageCheckpointsOrThrow(sink, registry, batch);
+        checkpoints = ClickHouse.stageCheckpointsOrThrow(sink, registry, batch, diffCheckpoints);
       } catch (exn) {
         sink.discard(entities);
         throw exn;

package/src/Staging.res

@@ -0,0 +1,298 @@
+// Filling a batch into a Rust-owned arena. The buffers below are lent by the
+// addon and must be written only between `begin` and `commit`/`abort` — the
+// rules, and why breaking them corrupts memory rather than failing a test, are
+// written down at the top of `packages/cli/src/columnar/mod.rs`.
+
+type kind =
+  | @as(0) F64
+  | @as(1) U64
+  | @as(2) I64
+  | @as(3) Text
+  | @as(4) Bytes
+
+let kindOfOrdinal = ordinal =>
+  switch ordinal {
+  | 0 => F64
+  | 1 => U64
+  | 2 => I64
+  | 3 => Text
+  | 4 => Bytes
+  | unknown => JsError.throwWithMessage(`Unknown staged column kind ${unknown->Int.toString}`)
+  }
+
+// The replacer closes over nothing but the column's name, so it is built once
+// with the column rather than once per column per batch.
+type column = {name: string, kind: kind, isNullable: bool, replacer: JSON.replacer}
+
+type begun = {handle: int, buffers: array<ArrayBuffer.t>}
+
+// What the addon exposes, so this module stays free of any one sink's API.
+type arena = {
+  beginStage: (~table: int, ~rows: int) => begun,
+  growStage: (~handle: int, ~column: int, ~needed: int, ~stale: ArrayBuffer.t) => ArrayBuffer.t,
+  commitStage: (~handle: int, ~buffers: array<ArrayBuffer.t>) => unit,
+  abortStage: (~handle: int, ~buffers: array<ArrayBuffer.t>) => unit,
+}
+
+type encodeResult = {read: int, written: int}
+type textEncoder
+@new external makeTextEncoder: unit => textEncoder = "TextEncoder"
+@send external encodeInto: (textEncoder, string, Uint8Array.t) => encodeResult = "encodeInto"
+
+%%private(let encoder = makeTextEncoder())
+
+@send external setFrom: (Uint8Array.t, Uint8Array.t, int) => unit = "set"
+
+// A variable-width column's payload and the offsets that cut it into rows.
+// `cursor` is where the next value starts — a row's bytes run from the previous
+// row's end to its own, so every row sets `ends`, the null ones included.
+// `slot` is which of the lent buffers carries `data`, since `grow` replaces it
+// and the commit has to detach what is live rather than what was handed out.
+type variable = {
+  mutable data: Uint8Array.t,
+  ends: Uint32Array.t,
+  slot: int,
+  mutable cursor: int,
+}
+
+// One per column kind, holding only the view that kind writes through.
+type storage =
+  | Floats(Float64Array.t)
+  | Unsigned(BigUint64Array.t)
+  | Signed(BigInt64Array.t)
+  | Text(variable)
+  | Bytes(variable)
+
+type builder = {
+  name: string,
+  isNullable: bool,
+  replacer: JSON.replacer,
+  index: int,
+  storage: storage,
+  nulls: Uint8Array.t,
+}
+
+type t = {
+  arena: arena,
+  handle: int,
+  buffers: array<ArrayBuffer.t>,
+  builders: array<builder>,
+}
+
+let begin = (arena, ~table, ~rows, ~columns: array<column>) => {
+  let {handle, buffers} = arena.beginStage(~table, ~rows)
+  let slot = ref(0)
+  let take = () => {
+    let buffer = buffers->Array.getUnsafe(slot.contents)
+    slot := slot.contents + 1
+    buffer
+  }
+  // Buffer order is the arena's: the values, then a variable column's offsets,
+  // then the null flags.
+  let takeVariable = () => {
+    let slot = slot.contents
+    let data = Uint8Array.fromBuffer(take())
+    let ends = Uint32Array.fromBuffer(take())
+    {data, ends, slot, cursor: 0}
+  }
+  let builders = columns->Array.mapWithIndex(({name, kind, isNullable, replacer}, index) => {
+    let storage = switch kind {
+    | F64 => Floats(Float64Array.fromBuffer(take()))
+    | U64 => Unsigned(BigUint64Array.fromBuffer(take()))
+    | I64 => Signed(BigInt64Array.fromBuffer(take()))
+    | Text => Text(takeVariable())
+    | Bytes => Bytes(takeVariable())
+    }
+    {name, isNullable, replacer, index, storage, nulls: Uint8Array.fromBuffer(take())}
+  })
+  {arena, handle, buffers, builders}
+}
+
+%%private(
+  let ensure = (stage, builder, variable, ~needed) =>
+    if needed > variable.data->TypedArray.length {
+      let fresh = stage.arena.growStage(
+        ~handle=stage.handle,
+        ~column=builder.index,
+        ~needed,
+        ~stale=variable.data->TypedArray.buffer,
+      )
+      stage.buffers->Array.setUnsafe(variable.slot, fresh)
+      variable.data = Uint8Array.fromBuffer(fresh)
+    }
+)
+
+external asString: unknown => string = "%identity"
+@val external toNumber: unknown => float = "Number"
+@val external toBigInt: unknown => bigint = "BigInt"
+@val external stringOf: unknown => string = "String"
+
+// No column holds NaN or Infinity, but nothing downstream refuses them well: a
+// list renders one as `null` on the way into JSON text, which the column then
+// refuses for a reason naming `null` rather than what the handler wrote, and a
+// scalar Float64 takes the raw bytes and stores a value no reader can render.
+// Refused here instead, where the value is still itself, with one message for
+// both shapes.
+let finiteOrThrow = (number: float, ~column) =>
+  if number->Float.isFinite {
+    number
+  } else {
+    JsError.throwWithMessage(
+      `${number->Float.toString} is not a finite number, so it cannot be stored in the \`${column}\` column. Store a finite number, or keep it out of the entity.`,
+    )
+  }
+
+let toText = (value: unknown, ~replacer) =>
+  switch value->typeof {
+  | #string => value->asString
+  | #bigint => value->stringOf
+  | _ => value->(Utils.magic: unknown => JSON.t)->JSON.stringify(~replacer)
+  }
+
+// Copies `text` in as one byte per character, or returns -1 at the first
+// character that needs more than one. An id, a hash, a decimal and an enum
+// variant are all ASCII, which is most of what a text column ever holds, and
+// this spares them the `subarray` that `encodeInto` needs to be given an
+// offset — one short-lived object per cell is what the batch pays otherwise.
+%%private(
+  let writeAscii: (Uint8Array.t, string, int) => int = %raw(`(data, text, offset) => {
+    const length = text.length;
+    for (let index = 0; index < length; index++) {
+      const code = text.charCodeAt(index);
+      if (code > 0x7f) {
+        return -1;
+      }
+      data[offset + index] = code;
+    }
+    return length;
+  }`)
+)
+
+%%private(
+  let writeText = (stage, builder, variable, ~row, text) => {
+    // One byte per UTF-16 unit is what ASCII needs, so the room for the fast
+    // path is the room for its guess. `read` says when the guess was short:
+    // UTF-8 spends at most three bytes per unit, which is what a surrogate pair
+    // costs across its two.
+    let units = text->String.length
+    stage->ensure(builder, variable, ~needed=variable.cursor + units)
+    let written = switch variable.data->writeAscii(text, variable.cursor) {
+    | -1 =>
+      let {read, written} =
+        encoder->encodeInto(text, variable.data->TypedArray.subarray(~start=variable.cursor))
+      if read < units {
+        stage->ensure(builder, variable, ~needed=variable.cursor + units * 3)
+        let {written} =
+          encoder->encodeInto(text, variable.data->TypedArray.subarray(~start=variable.cursor))
+        written
+      } else {
+        written
+      }
+    | ascii => ascii
+    }
+    variable.cursor = variable.cursor + written
+    variable.ends->TypedArray.set(row, variable.cursor)
+  }
+)
+
+%%private(
+  let writeBytes = (stage, builder, variable, ~row, bytes: Uint8Array.t) => {
+    let length = bytes->TypedArray.length
+    stage->ensure(builder, variable, ~needed=variable.cursor + length)
+    variable.data->setFrom(bytes, variable.cursor)
+    variable.cursor = variable.cursor + length
+    variable.ends->TypedArray.set(row, variable.cursor)
+  }
+)
+
+%%private(
+  let markNull = (builder, ~row) => {
+    builder.nulls->TypedArray.set(row, 1)
+    // A row with no value still ends where the one before it did, or the row
+    // after it would start before its own beginning.
+    switch builder.storage {
+    | Text(variable) | Bytes(variable) => variable.ends->TypedArray.set(row, variable.cursor)
+    | Floats(_) | Unsigned(_) | Signed(_) => ()
+    }
+  }
+)
+
+// RowBinary carries the raw integer, so a value the column cannot hold is not
+// rejected anywhere downstream — and a typed array reduces it modulo 2^64 on
+// the way in rather than refusing it, which would leave no trace at all.
+%%private(
+  let checkedBigInt = (value: unknown, ~builder, ~min, ~max) => {
+    let value = value->toBigInt
+    if value < min || value > max {
+      JsError.throwWithMessage(
+        `${value->BigInt.toString} is out of range for the \`${builder.name}\` column`,
+      )
+    }
+    value
+  }
+)
+
+%%private(
+  let writePresent = (stage, builder, ~row, value: unknown) =>
+    switch builder.storage {
+    | Floats(floats) =>
+      floats->TypedArray.set(row, value->toNumber->finiteOrThrow(~column=builder.name))
+    | Unsigned(unsigned) =>
+      unsigned->TypedArray.set(
+        row,
+        value->checkedBigInt(~builder, ~min=0n, ~max=18446744073709551615n),
+      )
+    | Signed(signed) =>
+      signed->TypedArray.set(
+        row,
+        value->checkedBigInt(~builder, ~min=-9223372036854775808n, ~max=9223372036854775807n),
+      )
+    | Text(variable) =>
+      stage->writeText(builder, variable, ~row, value->toText(~replacer=builder.replacer))
+    | Bytes(variable) =>
+      stage->writeBytes(builder, variable, ~row, value->(Utils.magic: unknown => Uint8Array.t))
+    }
+)
+
+%%private(let isAbsent = (value: unknown) => value === %raw(`undefined`) || value === %raw(`null`))
+
+// Writes one value of a row the handler set. `undefined`/`null` marks the row's
+// null bit, which a column that accepts NULL stores as such — and which one that
+// does not has no way to store: RowBinary carries no "absent", so the row would
+// land holding the type's zero, a value the handler never chose and that nothing
+// downstream could tell from one it did.
+let writeValue = (stage, ~column, ~row, value: unknown) => {
+  let builder = stage.builders->Array.getUnsafe(column)
+  if value->isAbsent {
+    if builder.isNullable {
+      builder->markNull(~row)
+    } else {
+      JsError.throwWithMessage(
+        `No value for the \`${builder.name}\` column, which is not nullable. Set the field before saving the entity, or make it optional in the schema.`,
+      )
+    }
+  } else {
+    stage->writePresent(builder, ~row, value)
+  }
+}
+
+let writeDeletedValue = (stage, ~column, ~row, value: unknown) => {
+  let builder = stage.builders->Array.getUnsafe(column)
+  if value->isAbsent {
+    builder->markNull(~row)
+  } else {
+    stage->writePresent(builder, ~row, value)
+  }
+}
+
+let columnCount = stage => stage.builders->Array.length
+
+// Ends the filling phase and returns the handle the write is asked for. Every
+// lent buffer is detached here, so a view left over from this stage throws on
+// its next write instead of reaching memory Rust is reading.
+let commit = stage => {
+  stage.arena.commitStage(~handle=stage.handle, ~buffers=stage.buffers)
+  stage.handle
+}
+
+let abort = stage => stage.arena.abortStage(~handle=stage.handle, ~buffers=stage.buffers)

package/src/Staging.res.mjs

@@ -0,0 +1,257 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+
+function kindOfOrdinal(ordinal) {
+  switch (ordinal) {
+    case 0 :
+      return 0;
+    case 1 :
+      return 1;
+    case 2 :
+      return 2;
+    case 3 :
+      return 3;
+    case 4 :
+      return 4;
+    default:
+      return Stdlib_JsError.throwWithMessage(`Unknown staged column kind ` + ordinal.toString());
+  }
+}
+
+let encoder = new TextEncoder();
+
+function begin(arena, table, rows, columns) {
+  let match = arena.beginStage(table, rows);
+  let buffers = match.buffers;
+  let slot = {
+    contents: 0
+  };
+  let take = () => {
+    let buffer = buffers[slot.contents];
+    slot.contents = slot.contents + 1 | 0;
+    return buffer;
+  };
+  let takeVariable = () => {
+    let slot$1 = slot.contents;
+    let data = new Uint8Array(take());
+    let ends = new Uint32Array(take());
+    return {
+      data: data,
+      ends: ends,
+      slot: slot$1,
+      cursor: 0
+    };
+  };
+  let builders = columns.map((param, index) => {
+    let storage;
+    switch (param.kind) {
+      case 0 :
+        storage = {
+          TAG: "Floats",
+          _0: new Float64Array(take())
+        };
+        break;
+      case 1 :
+        storage = {
+          TAG: "Unsigned",
+          _0: new BigUint64Array(take())
+        };
+        break;
+      case 2 :
+        storage = {
+          TAG: "Signed",
+          _0: new BigInt64Array(take())
+        };
+        break;
+      case 3 :
+        storage = {
+          TAG: "Text",
+          _0: takeVariable()
+        };
+        break;
+      case 4 :
+        storage = {
+          TAG: "Bytes",
+          _0: takeVariable()
+        };
+        break;
+    }
+    return {
+      name: param.name,
+      isNullable: param.isNullable,
+      replacer: param.replacer,
+      index: index,
+      storage: storage,
+      nulls: new Uint8Array(take())
+    };
+  });
+  return {
+    arena: arena,
+    handle: match.handle,
+    buffers: buffers,
+    builders: builders
+  };
+}
+
+function ensure(stage, builder, variable, needed) {
+  if (needed <= variable.data.length) {
+    return;
+  }
+  let fresh = stage.arena.growStage(stage.handle, builder.index, needed, variable.data.buffer);
+  stage.buffers[variable.slot] = fresh;
+  variable.data = new Uint8Array(fresh);
+}
+
+function finiteOrThrow(number, column) {
+  if (isFinite(number)) {
+    return number;
+  } else {
+    return Stdlib_JsError.throwWithMessage(number.toString() + ` is not a finite number, so it cannot be stored in the \`` + column + `\` column. Store a finite number, or keep it out of the entity.`);
+  }
+}
+
+function toText(value, replacer) {
+  let match = typeof value;
+  if (match === "bigint") {
+    return String(value);
+  } else if (match === "string") {
+    return value;
+  } else {
+    return JSON.stringify(value, replacer);
+  }
+}
+
+let writeAscii = ((data, text, offset) => {
+    const length = text.length;
+    for (let index = 0; index < length; index++) {
+      const code = text.charCodeAt(index);
+      if (code > 0x7f) {
+        return -1;
+      }
+      data[offset + index] = code;
+    }
+    return length;
+  });
+
+function markNull(builder, row) {
+  builder.nulls[row] = 1;
+  let match = builder.storage;
+  switch (match.TAG) {
+    case "Text" :
+    case "Bytes" :
+      break;
+    default:
+      return;
+  }
+  let variable = match._0;
+  variable.ends[row] = variable.cursor;
+}
+
+function checkedBigInt(value, builder, min, max) {
+  let value$1 = BigInt(value);
+  if (value$1 < min || value$1 > max) {
+    Stdlib_JsError.throwWithMessage(value$1.toString() + ` is out of range for the \`` + builder.name + `\` column`);
+  }
+  return value$1;
+}
+
+function writePresent(stage, builder, row, value) {
+  let floats = builder.storage;
+  switch (floats.TAG) {
+    case "Floats" :
+      floats._0[row] = finiteOrThrow(Number(value), builder.name);
+      return;
+    case "Unsigned" :
+      floats._0[row] = checkedBigInt(value, builder, 0n, 18446744073709551615n);
+      return;
+    case "Signed" :
+      floats._0[row] = checkedBigInt(value, builder, -9223372036854775808n, 9223372036854775807n);
+      return;
+    case "Text" :
+      let variable = floats._0;
+      let text = toText(value, builder.replacer);
+      let units = text.length;
+      ensure(stage, builder, variable, variable.cursor + units | 0);
+      let ascii = writeAscii(variable.data, text, variable.cursor);
+      let written;
+      if (ascii !== -1) {
+        written = ascii;
+      } else {
+        let match = encoder.encodeInto(text, variable.data.subarray(variable.cursor));
+        if (match.read < units) {
+          ensure(stage, builder, variable, variable.cursor + (units * 3 | 0) | 0);
+          written = encoder.encodeInto(text, variable.data.subarray(variable.cursor)).written;
+        } else {
+          written = match.written;
+        }
+      }
+      variable.cursor = variable.cursor + written | 0;
+      variable.ends[row] = variable.cursor;
+      return;
+    case "Bytes" :
+      let variable$1 = floats._0;
+      let length = value.length;
+      ensure(stage, builder, variable$1, variable$1.cursor + length | 0);
+      variable$1.data.set(value, variable$1.cursor);
+      variable$1.cursor = variable$1.cursor + length | 0;
+      variable$1.ends[row] = variable$1.cursor;
+      return;
+  }
+}
+
+function isAbsent(value) {
+  if (value === undefined) {
+    return true;
+  } else {
+    return value === null;
+  }
+}
+
+function writeValue(stage, column, row, value) {
+  let builder = stage.builders[column];
+  if (isAbsent(value)) {
+    if (builder.isNullable) {
+      return markNull(builder, row);
+    } else {
+      return Stdlib_JsError.throwWithMessage(`No value for the \`` + builder.name + `\` column, which is not nullable. Set the field before saving the entity, or make it optional in the schema.`);
+    }
+  } else {
+    return writePresent(stage, builder, row, value);
+  }
+}
+
+function writeDeletedValue(stage, column, row, value) {
+  let builder = stage.builders[column];
+  if (isAbsent(value)) {
+    return markNull(builder, row);
+  } else {
+    return writePresent(stage, builder, row, value);
+  }
+}
+
+function columnCount(stage) {
+  return stage.builders.length;
+}
+
+function commit(stage) {
+  stage.arena.commitStage(stage.handle, stage.buffers);
+  return stage.handle;
+}
+
+function abort(stage) {
+  stage.arena.abortStage(stage.handle, stage.buffers);
+}
+
+export {
+  kindOfOrdinal,
+  begin,
+  finiteOrThrow,
+  toText,
+  writeValue,
+  writeDeletedValue,
+  columnCount,
+  commit,
+  abort,
+}
+/* encoder Not a pure module */