envio 3.11.0 → 3.12.0

package/src/bindings/ClickHouse.res.mjs

@@ -5,6 +5,8 @@ import * as Table from "../db/Table.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as ChainId from "../ChainId.res.mjs";
 import * as Logging from "../Logging.res.mjs";
+import * as Staging from "../Staging.res.mjs";
+import * as Frontier from "../db/Frontier.res.mjs";
 import * as Internal from "../Internal.res.mjs";
 import * as Persistence from "../Persistence.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
@@ -176,7 +178,8 @@ let checkpointColumns = Stdlib_Array.filterMap(InternalTable.Checkpoints.columns
   let match = field._0;
   return {
     spec: makeColumnSpec(match.fieldName, undefined, param.clickHouseFieldType, match.isNullable, undefined),
-    valuesOf: param.valuesOf
+    valuesOf: param.valuesOf,
+    diffValuesOf: param.diffValuesOf
   };
 });
 
@@ -303,27 +306,24 @@ function makeConverters(entityConfig, scope, table) {
   };
 }
 
-function fillBuilders(table, converters, changes) {
-  let rows = changes.length;
-  let builders = table.columns.map(__x => ClickHouseSink.makeBuilder(__x, rows));
-  let columns = builders.length;
-  for (let row = 0; row < rows; ++row) {
+function fillStage(stage, converters, changes) {
+  let columns = Staging.columnCount(stage);
+  for (let row = 0, row_finish = changes.length; row < row_finish; ++row) {
     let change = changes[row];
     let match;
     match = change.type === "SET" ? [
         converters.setCells,
-        ClickHouseSink.writeValue
+        Staging.writeValue
       ] : [
         converters.deleteCells,
-        ClickHouseSink.writeDeletedValue
+        Staging.writeDeletedValue
       ];
     let write = match[1];
     let cells = match[0];
     for (let column = 0; column < columns; ++column) {
-      write(builders[column], row, cells[column](change));
+      write(stage, column, row, cells[column](change));
     }
   }
-  return builders;
 }
 
 function entityTable(sink, registry, entityConfig) {
@@ -347,27 +347,25 @@ function checkpointsTable(sink, registry) {
   return table$1;
 }
 
-function stageBuilders(sink, table, builders, rows) {
-  return sink.stage(table.handle, rows, builders.map(ClickHouseSink.builderPayload));
-}
-
-function stageCheckpointsOrThrow(sink, registry, batch) {
-  let rows = batch.checkpointIds.length;
+function stageCheckpointsOrThrow(sink, registry, batch, diffCheckpoints) {
+  let rows = batch.checkpointIds.length + diffCheckpoints.length | 0;
   if (rows === 0) {
     return null;
   }
   let table = checkpointsTable(sink, registry);
+  let stage = Staging.begin(ClickHouseSink.arena(sink), table.handle, rows, table.columns);
   try {
-    let builders = table.columns.map(__x => ClickHouseSink.makeBuilder(__x, rows));
-    builders.forEach((builder, index) => {
-      let columnValues = checkpointColumns[index].valuesOf(batch);
+    table.columns.forEach((param, column) => {
+      let source = checkpointColumns[column];
+      let columnValues = source.valuesOf(batch).concat(source.diffValuesOf(diffCheckpoints));
       for (let row = 0; row < rows; ++row) {
-        ClickHouseSink.writeValue(builder, row, columnValues[row]);
+        Staging.writeValue(stage, column, row, columnValues[row]);
       }
     });
-    return stageBuilders(sink, table, builders, rows);
+    return Staging.commit(stage);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
+    Staging.abort(stage);
     throw {
       RE_EXN_ID: Persistence.StorageError,
       message: `Failed to convert checkpoints for ClickHouse table "` + table.name + `"`,
@@ -385,6 +383,7 @@ function stageUpdatesOrThrow(sink, registry, changes, entityConfig, scope) {
   let table = entityTable(sink, registry, entityConfig);
   let tableName = table.name;
   let cacheKey = entityConfig.name + `|` + Internal.chainScopeToString(scope);
+  let stage = Staging.begin(ClickHouseSink.arena(sink), table.handle, rows, table.columns);
   try {
     let cached = registry.converters[cacheKey];
     let converters;
@@ -395,10 +394,11 @@ function stageUpdatesOrThrow(sink, registry, changes, entityConfig, scope) {
       registry.converters[cacheKey] = cached$1;
       converters = cached$1;
     }
-    let builders = fillBuilders(table, converters, changes);
-    return stageBuilders(sink, table, builders, rows);
+    fillStage(stage, converters, changes);
+    return Staging.commit(stage);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
+    Staging.abort(stage);
     throw {
       RE_EXN_ID: Persistence.StorageError,
       message: `Failed to convert items for ClickHouse table "` + tableName + `"`,
@@ -443,18 +443,25 @@ async function initialize(sink, entities) {
   }
 }
 
-async function resume(sink, checkpointId, chains, entities) {
+async function resume(sink, sequence, frontier, chains, entities) {
   let chainProgress = chains.map(chain => ({
     chainId: ChainId.toString(chain.id),
-    progressBlockNumber: chain.progressBlockNumber
+    progressBlockNumber: chain.progressBlockNumber,
+    committedCheckpointId: Frontier.get(frontier, chain.id).toString()
   }));
   try {
+    let tmp;
+    tmp = sequence !== "SharedAcrossChains";
     return await sink.resume({
-      checkpointId: checkpointId.toString(),
+      perChain: tmp,
       chainProgress: chainProgress,
-      historyTables: entities.map(entityConfig => entitySpec(entityConfig).historyTable),
-      replicated: Env.ClickHouse.replicated(),
-      databaseEngine: Env.ClickHouse.databaseEngine()
+      historyTables: entities.map(entityConfig => {
+        let spec = entitySpec(entityConfig);
+        return {
+          name: spec.historyTable,
+          chainIdColumn: spec.chainIdColumn
+        };
+      })
     });
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
@@ -480,7 +487,6 @@ export {
   makeRegistry,
   entityTable,
   checkpointsTable,
-  stageBuilders,
   stageCheckpointsOrThrow,
   stageUpdatesOrThrow,
   writeStagedOrThrow,

package/src/bindings/ClickHouseSink.res

@@ -9,9 +9,16 @@ type historySchema = {
   checkpointsTable: string,
   checkpointChainIdColumn: string,
   checkpointBlockNumberColumn: string,
+  chainsTable: string,
+  chainsCheckpointIdColumn: string,
 }
 
-type chainProgressInput = {chainId: string, progressBlockNumber: int}
+type chainProgressInput = {
+  chainId: string,
+  progressBlockNumber: int,
+  // Where the chain's own sequence stands, as Postgres has it committed.
+  committedCheckpointId: string,
+}
 
 type options = {
   url: string,
@@ -62,12 +69,14 @@ type initializeInput = {
   databaseEngine?: string,
 }
 
+// A history table and the column naming the chain its rows belong to. Absent
+// only for a cross-chain entity, which no per-chain sequence can produce.
+type historyTableInput = {name: string, chainIdColumn?: string}
+
 type resumeInput = {
-  checkpointId: string,
+  perChain: bool,
   chainProgress: array<chainProgressInput>,
-  historyTables: array<string>,
-  replicated: bool,
-  databaseEngine?: string,
+  historyTables: array<historyTableInput>,
 }
 
 type registeredTable = {
@@ -77,15 +86,6 @@ type registeredTable = {
   nullable: array<bool>,
 }
 
-type columnValuesInput = {
-  numbers?: Float64Array.t,
-  unsigned64?: BigUint64Array.t,
-  signed64?: BigInt64Array.t,
-  texts?: array<string>,
-  bytes?: array<Uint8Array.t>,
-  nulls?: Uint8Array.t,
-}
-
 @send
 external registerEntityTable: (t, entitySpec) => registeredTable = "registerEntityTable"
 
@@ -99,7 +99,30 @@ external registerCheckpointsTable: (t, array<columnSpec>) => registeredTable =
 external resume: (t, resumeInput) => promise<unit> = "resume"
 
 @send
-external stage: (t, ~table: int, ~rows: int, ~columns: array<columnValuesInput>) => int = "stage"
+external beginStage: (t, ~table: int, ~rows: int) => Staging.begun = "beginStage"
+
+@send
+external growStage: (
+  t,
+  ~handle: int,
+  ~column: int,
+  ~needed: int,
+  ~stale: ArrayBuffer.t,
+) => ArrayBuffer.t = "growStage"
+
+@send
+external commitStage: (t, ~handle: int, ~buffers: array<ArrayBuffer.t>) => unit = "commitStage"
+
+@send
+external abortStage: (t, ~handle: int, ~buffers: array<ArrayBuffer.t>) => unit = "abortStage"
+
+let arena = (sink): Staging.arena => {
+  beginStage: (~table, ~rows) => sink->beginStage(~table, ~rows),
+  growStage: (~handle, ~column, ~needed, ~stale) =>
+    sink->growStage(~handle, ~column, ~needed, ~stale),
+  commitStage: (~handle, ~buffers) => sink->commitStage(~handle, ~buffers),
+  abortStage: (~handle, ~buffers) => sink->abortStage(~handle, ~buffers),
+}
 
 @send
 external writeBatch: (t, ~entities: array<int>, ~checkpoints: Null.t<int>) => promise<unit> =
@@ -116,6 +139,8 @@ let historySchema = (): historySchema => {
   checkpointsTable: InternalTable.Checkpoints.table.tableName,
   checkpointChainIdColumn: (#chain_id: InternalTable.Checkpoints.field :> string),
   checkpointBlockNumberColumn: (#block_number: InternalTable.Checkpoints.field :> string),
+  chainsTable: InternalTable.Chains.table.tableName,
+  chainsCheckpointIdColumn: (#checkpoint_id: InternalTable.Chains.field :> string),
 }
 
 let make = (~url, ~username, ~password, ~database, ~chainIdMode: ChainId.mode, ~onWarning) =>
@@ -131,45 +156,6 @@ let make = (~url, ~username, ~password, ~database, ~chainIdMode: ChainId.mode, ~
     onWarning,
   )
 
-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 ClickHouse column kind ${unknown->Int.toString}`)
-  }
-
-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.
-%%private(
-  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.`,
-      )
-    }
-)
-
 // Visits every node on the way into JSON text. A bigint would make
 // `JSON.stringify` throw and fail the whole batch, so it travels as its digits.
 %%private(
@@ -177,7 +163,7 @@ external asString: unknown => string = "%identity"
     (_, value: JSON.t) =>
       switch value->typeof {
       | #bigint =>
-        value->(Utils.magic: JSON.t => unknown)->stringOf->(Utils.magic: string => JSON.t)
+        value->(Utils.magic: JSON.t => unknown)->Staging.stringOf->(Utils.magic: string => JSON.t)
       // A Uint8Array inside a list column travels as its byte values, which the
       // sink reads back into raw bytes.
       | #object =>
@@ -190,148 +176,21 @@ external asString: unknown => string = "%identity"
         | None => value
         }
       | #number =>
-        let _ = value->(Utils.magic: JSON.t => float)->finiteOrThrow(~column)
+        let _ = value->(Utils.magic: JSON.t => float)->Staging.finiteOrThrow(~column)
         value
       | _ => value
       }
 )
 
-// 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 table = {handle: int, name: string, columns: array<column>}
+type table = {handle: int, name: string, columns: array<Staging.column>}
 
 let makeTable = (~name, {handle, names, kinds, nullable}: registeredTable) => {
   handle,
   name,
-  columns: names->Array.mapWithIndex((name, index) => {
+  columns: names->Array.mapWithIndex((name, index): Staging.column => {
     name,
-    kind: kinds->Array.getUnsafe(index)->kindOfOrdinal,
+    kind: kinds->Array.getUnsafe(index)->Staging.kindOfOrdinal,
     isNullable: nullable->Array.getUnsafe(index),
     replacer: Replacer(jsonSafe(~column=name)),
   }),
 }
-
-let toText = (value: unknown, ~replacer) =>
-  switch value->typeof {
-  | #string => value->asString
-  | #bigint => value->stringOf
-  | _ => value->(Utils.magic: unknown => JSON.t)->JSON.stringify(~replacer)
-  }
-
-type builder = {
-  name: string,
-  kind: kind,
-  isNullable: bool,
-  floats: Float64Array.t,
-  unsigned: BigUint64Array.t,
-  signed: BigInt64Array.t,
-  texts: array<string>,
-  bytes: array<Uint8Array.t>,
-  replacer: JSON.replacer,
-  mutable nulls: option<Uint8Array.t>,
-  rows: int,
-}
-
-%%private(let noFloats = Float64Array.fromLength(0))
-%%private(let noUnsigned = BigUint64Array.fromLength(0))
-%%private(let noSigned = BigInt64Array.fromLength(0))
-%%private(let noBytes = Uint8Array.fromLength(0))
-
-let makeBuilder = ({name, kind, isNullable, replacer}: column, ~rows) => {
-  name,
-  kind,
-  isNullable,
-  floats: kind === F64 ? Float64Array.fromLength(rows) : noFloats,
-  unsigned: kind === U64 ? BigUint64Array.fromLength(rows) : noUnsigned,
-  signed: kind === I64 ? BigInt64Array.fromLength(rows) : noSigned,
-  texts: kind === Text ? Array.make(~length=rows, "") : [],
-  bytes: kind === Bytes ? Array.make(~length=rows, noBytes) : [],
-  replacer,
-  nulls: None,
-  rows,
-}
-
-let markNull = (builder, ~row) => {
-  let nulls = switch builder.nulls {
-  | Some(nulls) => nulls
-  | None =>
-    let nulls = Uint8Array.fromLength(builder.rows)
-    builder.nulls = Some(nulls)
-    nulls
-  }
-  nulls->TypedArray.set(row, 1)
-}
-
-// 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 = (builder, ~row, value: unknown) =>
-    switch builder.kind {
-    | F64 =>
-      builder.floats->TypedArray.set(row, value->toNumber->finiteOrThrow(~column=builder.name))
-    | U64 =>
-      builder.unsigned->TypedArray.set(
-        row,
-        value->checkedBigInt(~builder, ~min=0n, ~max=18446744073709551615n),
-      )
-    | I64 =>
-      builder.signed->TypedArray.set(
-        row,
-        value->checkedBigInt(~builder, ~min=-9223372036854775808n, ~max=9223372036854775807n),
-      )
-    | Text => builder.texts->Array.setUnsafe(row, value->toText(~replacer=builder.replacer))
-    | Bytes => builder.bytes->Array.setUnsafe(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 = (builder, ~row, value: unknown) =>
-  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 {
-    builder->writePresent(~row, value)
-  }
-
-let writeDeletedValue = (builder, ~row, value: unknown) =>
-  if value->isAbsent {
-    builder->markNull(~row)
-  } else {
-    builder->writePresent(~row, value)
-  }
-
-let builderPayload = (builder): columnValuesInput => {
-  let base = {nulls: ?builder.nulls}
-  switch builder.kind {
-  | F64 => {...base, numbers: builder.floats}
-  | U64 => {...base, unsigned64: builder.unsigned}
-  | I64 => {...base, signed64: builder.signed}
-  | Text => {...base, texts: builder.texts}
-  | Bytes => {...base, bytes: builder.bytes}
-  }
-}

package/src/bindings/ClickHouseSink.res.mjs

@@ -3,10 +3,22 @@
 import * as Core from "../Core.res.mjs";
 import * as Table from "../db/Table.res.mjs";
 import * as Utils from "../Utils.res.mjs";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Staging from "../Staging.res.mjs";
 import * as EntityHistory from "../db/EntityHistory.res.mjs";
 import * as InternalTable from "../db/InternalTable.res.mjs";
-import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+
+function arena(sink) {
+  return {
+    beginStage: (table, rows) => sink.beginStage(table, rows),
+    growStage: (handle, column, needed, stale) => sink.growStage(handle, column, needed, stale),
+    commitStage: (handle, buffers) => {
+      sink.commitStage(handle, buffers);
+    },
+    abortStage: (handle, buffers) => {
+      sink.abortStage(handle, buffers);
+    }
+  };
+}
 
 function historySchema() {
   return {
@@ -17,7 +29,9 @@ function historySchema() {
     setVariant: "SET",
     checkpointsTable: InternalTable.Checkpoints.table.tableName,
     checkpointChainIdColumn: "chain_id",
-    checkpointBlockNumberColumn: "block_number"
+    checkpointBlockNumberColumn: "block_number",
+    chainsTable: InternalTable.Chains.table.tableName,
+    chainsCheckpointIdColumn: "checkpoint_id"
   };
 }
 
@@ -32,31 +46,6 @@ function make(url, username, password, database, chainIdMode, onWarning) {
   }, onWarning);
 }
 
-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 ClickHouse column kind ` + ordinal.toString());
-  }
-}
-
-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 jsonSafe(column) {
   return (param, value) => {
     let match = typeof value;
@@ -65,7 +54,7 @@ function jsonSafe(column) {
     }
     if (match !== "object") {
       if (match === "number") {
-        finiteOrThrow(value, column);
+        Staging.finiteOrThrow(value, column);
         return value;
       } else {
         return value;
@@ -88,159 +77,17 @@ function makeTable(name, param) {
     name: name,
     columns: param.names.map((name, index) => ({
       name: name,
-      kind: kindOfOrdinal(kinds[index]),
+      kind: Staging.kindOfOrdinal(kinds[index]),
       isNullable: nullable[index],
       replacer: jsonSafe(name)
     }))
   };
 }
 
-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 noFloats = new Float64Array(0);
-
-let noUnsigned = new BigUint64Array(0);
-
-let noSigned = new BigInt64Array(0);
-
-let noBytes = new Uint8Array(0);
-
-function makeBuilder(param, rows) {
-  let kind = param.kind;
-  return {
-    name: param.name,
-    kind: kind,
-    isNullable: param.isNullable,
-    floats: kind === 0 ? new Float64Array(rows) : noFloats,
-    unsigned: kind === 1 ? new BigUint64Array(rows) : noUnsigned,
-    signed: kind === 2 ? new BigInt64Array(rows) : noSigned,
-    texts: kind === 3 ? Stdlib_Array.make(rows, "") : [],
-    bytes: kind === 4 ? Stdlib_Array.make(rows, noBytes) : [],
-    replacer: param.replacer,
-    nulls: undefined,
-    rows: rows
-  };
-}
-
-function markNull(builder, row) {
-  let nulls = builder.nulls;
-  let nulls$1;
-  if (nulls !== undefined) {
-    nulls$1 = nulls;
-  } else {
-    let nulls$2 = new Uint8Array(builder.rows);
-    builder.nulls = nulls$2;
-    nulls$1 = nulls$2;
-  }
-  nulls$1[row] = 1;
-}
-
-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(builder, row, value) {
-  let match = builder.kind;
-  switch (match) {
-    case 0 :
-      builder.floats[row] = finiteOrThrow(Number(value), builder.name);
-      return;
-    case 1 :
-      builder.unsigned[row] = checkedBigInt(value, builder, 0n, 18446744073709551615n);
-      return;
-    case 2 :
-      builder.signed[row] = checkedBigInt(value, builder, -9223372036854775808n, 9223372036854775807n);
-      return;
-    case 3 :
-      builder.texts[row] = toText(value, builder.replacer);
-      return;
-    case 4 :
-      builder.bytes[row] = value;
-      return;
-  }
-}
-
-function isAbsent(value) {
-  if (value === undefined) {
-    return true;
-  } else {
-    return value === null;
-  }
-}
-
-function writeValue(builder, row, value) {
-  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(builder, row, value);
-  }
-}
-
-function writeDeletedValue(builder, row, value) {
-  if (isAbsent(value)) {
-    return markNull(builder, row);
-  } else {
-    return writePresent(builder, row, value);
-  }
-}
-
-function builderPayload(builder) {
-  let base_nulls = builder.nulls;
-  let base = {
-    nulls: base_nulls
-  };
-  let match = builder.kind;
-  switch (match) {
-    case 0 :
-      let newrecord = {...base};
-      newrecord.numbers = builder.floats;
-      return newrecord;
-    case 1 :
-      let newrecord$1 = {...base};
-      newrecord$1.unsigned64 = builder.unsigned;
-      return newrecord$1;
-    case 2 :
-      let newrecord$2 = {...base};
-      newrecord$2.signed64 = builder.signed;
-      return newrecord$2;
-    case 3 :
-      let newrecord$3 = {...base};
-      newrecord$3.texts = builder.texts;
-      return newrecord$3;
-    case 4 :
-      let newrecord$4 = {...base};
-      newrecord$4.bytes = builder.bytes;
-      return newrecord$4;
-  }
-}
-
 export {
+  arena,
   historySchema,
   make,
-  kindOfOrdinal,
   makeTable,
-  toText,
-  makeBuilder,
-  markNull,
-  writeValue,
-  writeDeletedValue,
-  builderPayload,
 }
-/* noFloats Not a pure module */
+/* Core Not a pure module */