envio 3.11.0 → 3.12.1

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 */

package/src/TestIndexer.res

@@ -75,15 +75,10 @@ let handleLoad = (state: testIndexerState, ~tableName: string, ~filter: EntityFi
   | None => []
   | Some(entityConfig) =>
     let entityDict = state.entities->Dict.get(tableName)->Option.getOr(Dict.make())
-    let matched =
-      entityDict
-      ->Dict.valuesToArray
-      ->Array.filter(entity => {
-        // The store holds decoded entities and the filter carries decoded values,
-        // so compare directly (same approach as InMemoryTable) — no JSON round-trip.
-        let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
-        filter->EntityFilter.matches(~entity=entityAsDict)
-      })
+    // The store holds decoded entities and the filter carries decoded values,
+    // so compare directly (same approach as InMemoryTable) — no JSON round-trip.
+    let matcher = filter->EntityFilter.makeMatcher(~table=entityConfig.table)
+    let matched = entityDict->Dict.valuesToArray->Array.filter(matcher)
     // The chain is already fixed by the scope the load ran for, so the loaded
     // entity is handed back in the shape the handlers see.
     switch entityConfig.table->Table.getChainIdField {
@@ -266,6 +261,7 @@ let makeInitialState = (
       sourceBlockNumber: processChainConfig.endBlock->Option.getOr(0),
       maxReorgDepth: 0, // No reorg support in test indexer
       progressBlockNumber: -1,
+      progressBlockTime: None,
       numEventsProcessed: 0.,
       firstEventBlockNumber: None,
       timestampCaughtUpToHeadOrEndblock: None,
@@ -279,7 +275,7 @@ let makeInitialState = (
     envioInfo: Some(JSON.Encode.object(Dict.make())),
     cache: Dict.make(),
     chains,
-    checkpointId: InternalTable.Checkpoints.initialCheckpointId,
+    checkpointFrontier: Frontier.empty(),
     reorgCheckpoints: [],
   }
 }
@@ -543,23 +539,12 @@ let makeEntityGetWhere = (~state: testIndexerState, ~entityConfig: Internal.enti
         `Cannot call ${entityConfig.name}.getWhere() while indexer.process() is running. ` ++ "Wait for process() to complete before accessing entities directly.",
       )
     }
-    let filters =
-      filter->EntityFilter.parseGetWhereOrThrow(
-        ~entityName=entityConfig.name,
-        ~table=entityConfig.table,
-      )
+    let matcher =
+      filter
+      ->EntityFilter.parseOrThrow(~entityName=entityConfig.name, ~table=entityConfig.table)
+      ->EntityFilter.makeMatcher(~table=entityConfig.table)
     let entityDict = state.entities->Dict.get(entityConfig.name)->Option.getOr(Dict.make())
-    // parseGetWhereOrThrow expands an operator group into alternatives whose
-    // matches are disjoint, so the union needs no dedup.
-    Promise.resolve(
-      entityDict
-      ->Dict.valuesToArray
-      ->Array.filter(entity => {
-        let entityAsDict = entity->(Utils.magic: Internal.entity => dict<EntityFilter.FieldValue.t>)
-        filters->Array.some(filter => filter->EntityFilter.matches(~entity=entityAsDict))
-      })
-      ->Array.map(copyEntity),
-    )
+    Promise.resolve(entityDict->Dict.valuesToArray->Array.filter(matcher)->Array.map(copyEntity))
   }
 }
 
@@ -590,7 +575,7 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     JsError.throwWithMessage(
       "TestIndexer: initialize should not be called; the initial state is derived from config.",
     ),
-  resumeInitialState: async (~entities as _, ~throwIfIncompatible as _) =>
+  resumeInitialState: async (~entities as _, ~chainIds as _, ~throwIfIncompatible as _) =>
     JsError.throwWithMessage(
       "TestIndexer: resumeInitialState should not be called; the initial state is derived from config.",
     ),
@@ -599,13 +584,12 @@ let makeInMemoryStorage = (~state: testIndexerState): Persistence.storage => {
     ->handleLoad(~tableName=table.tableName, ~filter)
     ->(Utils.magic: array<Internal.entity> => array<unknown>),
   // The in-memory storage has no indexes to build, and it's always ready.
-  ensureQueryIndexes: async (~table as _, ~filters as _) => (),
-  ensureSchemaIndexes: async (~entities as _) => (),
+  ensureQueryIndexes: async (~entityConfig as _, ~scope as _, ~filters as _) => (),
+  ensureSchemaIndexes: async (~entities as _, ~chainIds as _) => (),
   finalizeBackfill: async (~entities as _, ~chainIds as _, ~readyAt as _) => (),
   writeBatch: async (
     ~batch,
     ~rollback as _,
-    ~isInReorgThreshold as _,
     ~config,
     ~allEntities as _,
     ~updatedEffectsCache as _,

package/src/TestIndexer.res.mjs

@@ -8,6 +8,7 @@ import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as EntityId from "./EntityId.res.mjs";
+import * as Frontier from "./db/Frontier.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
@@ -19,7 +20,6 @@ import * as EntityFilter from "./db/EntityFilter.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as HandlerLoader from "./HandlerLoader.res.mjs";
-import * as InternalTable from "./db/InternalTable.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as SimulateItems from "./SimulateItems.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -56,7 +56,8 @@ function handleLoad(state, tableName, filter) {
     return [];
   }
   let entityDict = Stdlib_Option.getOr(state.entities[tableName], {});
-  let matched = Object.values(entityDict).filter(entity => EntityFilter.matches(filter, entity));
+  let matcher = EntityFilter.makeMatcher(filter, entityConfig.table);
+  let matched = Object.values(entityDict).filter(matcher);
   let field = Table.getChainIdField(entityConfig.table);
   if (field !== undefined) {
     return matched.map(entity => {
@@ -183,6 +184,7 @@ function makeInitialState(config, processConfigChains, addressRowsByChain, contr
       endBlock: processChainConfig.endBlock,
       maxReorgDepth: 0,
       progressBlockNumber: -1,
+      progressBlockTime: undefined,
       numEventsProcessed: 0,
       firstEventBlockNumber: undefined,
       timestampCaughtUpToHeadOrEndblock: undefined,
@@ -196,7 +198,7 @@ function makeInitialState(config, processConfigChains, addressRowsByChain, contr
     envioInfo: {},
     cache: {},
     chains: chains,
-    checkpointId: InternalTable.Checkpoints.initialCheckpointId,
+    checkpointFrontier: Frontier.empty(),
     reorgCheckpoints: []
   };
 }
@@ -375,9 +377,9 @@ function makeEntityGetWhere(state, entityConfig) {
     if (state.processInProgress) {
       Stdlib_JsError.throwWithMessage(`Cannot call ` + entityConfig.name + `.getWhere() while indexer.process() is running. ` + "Wait for process() to complete before accessing entities directly.");
     }
-    let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
+    let matcher = EntityFilter.makeMatcher(EntityFilter.parseOrThrow(filter, entityConfig.name, entityConfig.table), entityConfig.table);
     let entityDict = Stdlib_Option.getOr(state.entities[entityConfig.name], {});
-    return Promise.resolve(Object.values(entityDict).filter(entity => filters.some(filter => EntityFilter.matches(filter, entity))).map(copyEntity));
+    return Promise.resolve(Object.values(entityDict).filter(matcher).map(copyEntity));
   };
 }
 
@@ -386,10 +388,10 @@ function makeInMemoryStorage(state) {
     name: "test-inmemory",
     isInitialized: async () => true,
     initialize: async (param, param$1, param$2, param$3, param$4) => Stdlib_JsError.throwWithMessage("TestIndexer: initialize should not be called; the initial state is derived from config."),
-    resumeInitialState: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
+    resumeInitialState: async (param, param$1, param$2) => Stdlib_JsError.throwWithMessage("TestIndexer: resumeInitialState should not be called; the initial state is derived from config."),
     loadOrThrow: async (filter, table) => handleLoad(state, table.tableName, filter),
-    ensureQueryIndexes: async (param, param$1) => {},
-    ensureSchemaIndexes: async param => {},
+    ensureQueryIndexes: async (param, param$1, param$2) => {},
+    ensureSchemaIndexes: async (param, param$1) => {},
     finalizeBackfill: async (param, param$1, param$2) => {},
     dumpEffectCache: async () => {},
     reset: async () => {},
@@ -399,7 +401,7 @@ function makeInMemoryStorage(state) {
     getRollbackTargetCheckpoint: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
     getRollbackProgressDiff: async param => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
     getRollbackData: async (param, param$1) => Stdlib_JsError.throwWithMessage("TestIndexer: Rollback is not supported. The runner forces rollbackOnReorg off, so this should be unreachable."),
-    writeBatch: async (batch, param, param$1, config, param$2, param$3, updatedEntities, registeredAddresses, param$4, param$5) => handleWriteBatch(state, config, updatedEntities, registeredAddresses, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointEventsProcessed),
+    writeBatch: async (batch, param, config, param$1, param$2, updatedEntities, registeredAddresses, param$3, param$4) => handleWriteBatch(state, config, updatedEntities, registeredAddresses, batch.checkpointIds, batch.checkpointChainIds, batch.checkpointBlockNumbers, batch.checkpointEventsProcessed),
     close: async () => {}
   };
 }

package/src/UserContext.res

@@ -95,6 +95,7 @@ let initEffect = (params: contextParams) => {
         input,
         context: effectContext,
         cacheKey: input->S.reverseConvertOrThrow(effect.input)->Utils.Hash.makeOrThrow,
+        chainId: handlerChainId,
         checkpointId: params.checkpointId,
       }
       LoadLayer.loadEffect(
@@ -121,39 +122,20 @@ type entityContextParams = {
 // The handler context is always chain-scoped, so a per-chain entity resolves to
 // the chain the handler runs on and a cross-chain one to the shared partition.
 let entityScope = (params: entityContextParams) =>
-  params.entityConfig->InMemoryStore.entityScope(
-    ~chainId=params.item->Internal.getItemChainId,
-  )
-
-let getWhereHandler = (params: entityContextParams, filter: dict<dict<unknown>>) => {
-  let entityConfig = params.entityConfig
-
-  @inline
-  let loadWithFilter = filter =>
-    LoadLayer.loadByFilter(
-      ~loadManager=params.loadManager,
-      ~persistence=params.persistence,
-      ~entityConfig,
-      ~scope=params->entityScope,
-      ~indexerState=params.indexerState,
-      ~shouldGroup=params.isPreload,
-      ~item=params.item,
-      ~ecosystem=params.config.ecosystem,
-      ~filter,
-    )
+  params.entityConfig->InMemoryStore.entityScope(~chainId=params.item->Internal.getItemChainId)
 
-  switch filter->EntityFilter.parseGetWhereOrThrow(
-    ~entityName=entityConfig.name,
-    ~table=entityConfig.table,
-  ) {
-  | [single] => loadWithFilter(single)
-  | filters =>
-    filters
-    ->Array.map(filter => loadWithFilter(filter))
-    ->Promise.all
-    ->Promise.thenResolve(results => results->Array.flat)
-  }
-}
+let getWhereHandler = (params: entityContextParams, filter: dict<dict<unknown>>) =>
+  LoadLayer.loadByFilter(
+    ~loadManager=params.loadManager,
+    ~persistence=params.persistence,
+    ~entityConfig=params.entityConfig,
+    ~scope=params->entityScope,
+    ~indexerState=params.indexerState,
+    ~shouldGroup=params.isPreload,
+    ~item=params.item,
+    ~ecosystem=params.config.ecosystem,
+    ~filter,
+  )
 
 let noopSet = (_entity: Internal.entity) => ()
 let noopDeleteUnsafe = (_entityId: EntityId.t) => ()
@@ -171,14 +153,16 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
     let prop = prop->(Utils.magic: unknown => string)
 
     let isClickHouseOnly = !params.entityConfig.storage.postgres
+    let scope = params->entityScope
+    let committedCheckpointId = params.indexerState->IndexerState.committedCheckpointIdFor(~scope)
 
     let set = params.isPreload
       ? noopSet
       : (entity: Internal.entity) => {
           params.indexerState
-          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig, ~scope=params->entityScope)
+          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig, ~scope)
           ->InMemoryTable.Entity.set(
-            ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
+            ~committedCheckpointId,
             Set({
               entityId: entity.id->EntityId.unsafeOfString,
               checkpointId: params.checkpointId,
@@ -288,9 +272,9 @@ let entityTraps: Utils.Proxy.traps<entityContextParams> = {
       } else {
         entityId => {
           params.indexerState
-          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig, ~scope=params->entityScope)
+          ->InMemoryStore.getInMemTable(~entityConfig=params.entityConfig, ~scope)
           ->InMemoryTable.Entity.set(
-            ~committedCheckpointId=params.indexerState->IndexerState.committedCheckpointId,
+            ~committedCheckpointId,
             Delete({
               entityId,
               checkpointId: params.checkpointId,

package/src/UserContext.res.mjs

@@ -64,6 +64,7 @@ function initEffect(params) {
       input: input,
       context: effectContext,
       cacheKey: effectArgs_cacheKey,
+      chainId: handlerChainId,
       checkpointId: effectArgs_checkpointId
     };
     return LoadLayer.loadEffect(params.loadManager, params.persistence, effect, effectArgs, scope, params.indexerState, params.isPreload, params.item, params.config.ecosystem);
@@ -76,13 +77,7 @@ function entityScope(params) {
 }
 
 function getWhereHandler(params, filter) {
-  let entityConfig = params.entityConfig;
-  let filters = EntityFilter.parseGetWhereOrThrow(filter, entityConfig.name, entityConfig.table);
-  if (filters.length !== 1) {
-    return Promise.all(filters.map(filter => LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter))).then(results => results.flat());
-  } else {
-    return LoadLayer.loadByFilter(params.loadManager, params.persistence, entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filters[0]);
-  }
+  return LoadLayer.loadByFilter(params.loadManager, params.persistence, params.entityConfig, entityScope(params), params.indexerState, params.isPreload, params.item, params.config.ecosystem, filter);
 }
 
 function noopSet(_entity) {
@@ -99,7 +94,9 @@ function throwClickHouseReadOnly(entityConfig, op) {
 
 let entityTraps_get = (params, prop) => {
   let isClickHouseOnly = !params.entityConfig.storage.postgres;
-  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
+  let scope = entityScope(params);
+  let committedCheckpointId = IndexerState.committedCheckpointIdFor(params.indexerState, scope);
+  let set = params.isPreload ? noopSet : entity => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, scope), committedCheckpointId, {
       type: "SET",
       entityId: entity.id,
       entity: entity,
@@ -110,7 +107,7 @@ let entityTraps_get = (params, prop) => {
       if (params.isPreload) {
         return noopDeleteUnsafe;
       } else {
-        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, entityScope(params)), IndexerState.committedCheckpointId(params.indexerState), {
+        return entityId => InMemoryTable.Entity.set(InMemoryStore.getInMemTable(params.indexerState, params.entityConfig, scope), committedCheckpointId, {
           type: "DELETE",
           entityId: entityId,
           checkpointId: params.checkpointId

package/src/Utils.res

@@ -166,6 +166,15 @@ module Dict = {
 
   let merge: (dict<'a>, dict<'a>) => dict<'a> = %raw(`(dictA, dictB) => ({...dictA, ...dictB})`)
 
+  // Keeps every key either dict has; `pick` decides a key both have.
+  let mergeWith: (dict<'a>, dict<'a>, ('a, 'a) => 'a) => dict<'a> = %raw(`(a, b, pick) => {
+    var merged = {...a}, i;
+    for (i in b) {
+      merged[i] = i in merged ? pick(merged[i], b[i]) : b[i];
+    }
+    return merged;
+  }`)
+
   @val
   external mergeInPlace: (dict<'a>, dict<'a>) => dict<'a> = "Object.assign"
 
@@ -264,7 +273,7 @@ module Dict = {
 }
 
 module Math = {
-  let minOptInt = (a, b) =>
+  let minOptInt = (a: option<int>, b: option<int>) =>
     switch (a, b) {
     | (Some(a), Some(b)) => Some(a < b ? a : b)
     | (Some(a), None) => Some(a)
@@ -365,9 +374,6 @@ module Array = {
   /**
 Helper to check if a value exists in an array
 */
-  let includes = (arr: array<'a>, val: 'a) =>
-    arr->Array.find(item => item == val)->Stdlib.Option.isSome
-
   let isEmpty = (arr: array<_>) =>
     switch arr {
     | [] => true

package/src/Utils.res.mjs

@@ -6,11 +6,9 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_BigInt from "@rescript/runtime/lib/es6/Stdlib_BigInt.js";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
-import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
@@ -114,6 +112,14 @@ function pushMany(dict, key, values) {
 
 let merge = ((dictA, dictB) => ({...dictA, ...dictB}));
 
+let mergeWith = ((a, b, pick) => {
+    var merged = {...a}, i;
+    for (i in b) {
+      merged[i] = i in merged ? pick(merged[i], b[i]) : b[i];
+    }
+    return merged;
+  });
+
 let mapValues = ((dict, f) => {
     var target = {}, i;
     for (i in dict) {
@@ -197,6 +203,7 @@ let Dict = {
   push: push,
   pushMany: pushMany,
   merge: merge,
+  mergeWith: mergeWith,
   mapValues: mapValues,
   filterMapValues: filterMapValues,
   mapValuesToArray: mapValuesToArray,
@@ -212,19 +219,17 @@ let Dict = {
 };
 
 function minOptInt(a, b) {
-  if (a === undefined) {
+  if (a !== undefined) {
     if (b !== undefined) {
-      return Primitive_option.some(Primitive_option.valFromOption(b));
+      return a < b ? a : b;
     } else {
-      return;
+      return a;
     }
+  } else if (b !== undefined) {
+    return b;
+  } else {
+    return;
   }
-  let a$1 = Primitive_option.valFromOption(a);
-  if (b === undefined) {
-    return Primitive_option.some(a$1);
-  }
-  let b$1 = Primitive_option.valFromOption(b);
-  return Primitive_option.some(Primitive_object.lessthan(a$1, b$1) ? a$1 : b$1);
 }
 
 let $$Math = {
@@ -315,10 +320,6 @@ function transposeResults(results) {
   };
 }
 
-function includes(arr, val) {
-  return Stdlib_Option.isSome(arr.find(item => Primitive_object.equal(item, val)));
-}
-
 function isEmpty$1(arr) {
   return arr.length === 0;
 }
@@ -426,7 +427,6 @@ let $$Array$1 = {
   clearInPlace: clearInPlace$1,
   setIndexImmutable: setIndexImmutable,
   transposeResults: transposeResults,
-  includes: includes,
   isEmpty: isEmpty$1,
   notEmpty: notEmpty,
   awaitEach: awaitEach,