envio 3.15.0 → 3.16.0

package/src/sources/SourceManager.res

@@ -85,7 +85,7 @@ type t = {
   // Should take into consideration partitions fetching for previous states (before rollback)
   mutable fetchingPartitionsCount: int,
   recoveryTimeout: float,
-  retryBackoffScale: float,
+  clock: Clock.t,
   // Why a source was last disabled for good. A disabled source is never
   // retried, so by the time the manager runs out of sources this is the reason
   // it did — and the only thing that tells a caller what to change.
@@ -93,11 +93,10 @@ type t = {
   mutable hasRealtime: bool,
   mutable committedRateLimitTimeMs: float,
   mutable rateLimitWaiters: int,
-  // Wall-clock timestamp (Date.now()) when the current rate-limit window
-  // started, or None if not currently waiting. Wall-clock so consumers
-  // (TUI) can compute elapsed time with their own Date.now() reads.
+  // When the current rate-limit window started on `clock`, or None if not
+  // currently waiting.
   mutable activeRateLimitStartMs: option<float>,
-  // Wall-clock timestamp by which the server expects the longest current
+  // Timestamp on `clock` by which the server expects the longest current
   // wait to clear. Tracks the latest reset across concurrent waiters so
   // the displayed countdown reflects when the indexer will actually retry.
   mutable activeRateLimitResetAtMs: option<float>,
@@ -206,20 +205,20 @@ let inFlightCount = sourceManager => sourceManager.fetchingPartitionsCount
 let getRateLimitTimeMs = sourceManager =>
   sourceManager.committedRateLimitTimeMs +.
   switch sourceManager.activeRateLimitStartMs {
-  | Some(startMs) => Date.now() -. startMs
+  | Some(startMs) => sourceManager.clock.now() -. startMs
   | None => 0.0
   }
 
 let getRateLimitResetInMs = sourceManager =>
   switch sourceManager.activeRateLimitResetAtMs {
   | Some(resetAt) =>
-    let remaining = resetAt -. Date.now()
+    let remaining = resetAt -. sourceManager.clock.now()
     remaining > 0.0 ? Some(remaining) : None
   | None => None
   }
 
 let startRateLimitTimeout = (sourceManager, ~resetMs) => {
-  let now = Date.now()
+  let now = sourceManager.clock.now()
   if sourceManager.rateLimitWaiters === 0 {
     sourceManager.activeRateLimitStartMs = Some(now)
   }
@@ -237,7 +236,7 @@ let stopRateLimitTimeout = sourceManager => {
     switch sourceManager.activeRateLimitStartMs {
     | Some(startMs) =>
       sourceManager.committedRateLimitTimeMs =
-        sourceManager.committedRateLimitTimeMs +. Date.now() -. startMs
+        sourceManager.committedRateLimitTimeMs +. sourceManager.clock.now() -. startMs
       sourceManager.activeRateLimitStartMs = None
     | None => ()
     }
@@ -259,16 +258,8 @@ let waitForRateLimitReset = async (sourceManager: t, ~resetMs, ~retry, ~logger)
         ->Int.toString}s. For higher limits upgrade your plan at https://envio.dev/app/api-tokens.`,
     ~params={"retry": retry, "waitMs": waitMs},
   )
-  let waitedAt = Date.now()
   sourceManager->startRateLimitTimeout(~resetMs=waitMs)
-  await Utils.delay(waitMs)
-  // Timers run on the event loop's cached clock, so one can fire with Date.now()
-  // a millisecond short of the wait it was set for, and the wait is counted by
-  // Date.now(). Temporary until main takes the same fix.
-  let short = waitedAt +. waitMs->Int.toFloat -. Date.now()
-  if short > 0. {
-    await Utils.delay(short->Math.ceil->Float.toInt)
-  }
+  await sourceManager.clock->Clock.delay(~label="rate-limit reset", waitMs)
   sourceManager->stopRateLimitTimeout
 }
 
@@ -354,11 +345,12 @@ type timing = {
   reducedPollingInterval?: int,
   recoveryTimeout?: float,
   getHeightRetryInterval?: (~retry: int) => int,
-  retryBackoffScale?: float,
   heightPollTimeout?: int,
+  clock?: Clock.t,
 }
 
 let make = (~sources: array<Source.t>, ~logger: Logger.t, ~isRealtime, ~timing: timing={}) => {
+  let clock = timing.clock->Option.getOr(Clock.real)
   let newBlockStallTimeout = timing.newBlockStallTimeout->Option.getOr(60_000)
   let newBlockStallTimeoutRealtime = timing.newBlockStallTimeoutRealtime->Option.getOr(20_000)
   let stalledPollingInterval = timing.stalledPollingInterval->Option.getOr(5_000)
@@ -392,6 +384,7 @@ let make = (~sources: array<Source.t>, ~logger: Logger.t, ~isRealtime, ~timing:
           ~recordRequestStats=stats => requestStats->recordStatsInto(stats),
           ~getHeightRetryInterval,
           ~pollTimeoutMillis=timing.heightPollTimeout->Option.getOr(60_000),
+          ~clock,
         ),
         disabled: false,
         lastFailedAt: None,
@@ -408,7 +401,7 @@ let make = (~sources: array<Source.t>, ~logger: Logger.t, ~isRealtime, ~timing:
     stalledPollingInterval,
     reducedPollingInterval,
     recoveryTimeout,
-    retryBackoffScale: timing.retryBackoffScale->Option.getOr(1.),
+    clock,
     statusStart: Performance.now(),
     status: Idle,
     idleSeconds: 0.,
@@ -517,8 +510,8 @@ let compareByOldestFailure = (a: sourceState, b: sourceState) =>
   }
 
 // Priority: working primaries > working secondaries > all primaries.
-let getNextSources = (sourceManager, ~isRealtime, ~excludedSources=?) => {
-  let now = Date.now()
+let getNextSources = (sourceManager: t, ~isRealtime, ~excludedSources=?) => {
+  let now = sourceManager.clock.now()
   let workingPrimarySources = []
   let allPrimarySources = []
   let workingSecondarySources = []
@@ -589,10 +582,8 @@ let retryBackoffMillis = retry =>
 // 0, these must never busy-loop when there is no other source to move to.
 let minRecoverableBackoffMillis = 50
 
-// The logged backoff stays the unscaled one, so a scaled-down test still reads
-// the schedule an operator would see.
 let sleepBackoff = (sourceManager: t, millis) =>
-  Utils.delay((millis->Int.toFloat *. sourceManager.retryBackoffScale)->Float.toInt)
+  sourceManager.clock->Clock.delay(~label="retry backoff", millis)
 
 // Back off before retrying the same request, failing the source over first when
 // another one can actually take over. Marking `lastFailedAt` only demotes this
@@ -614,7 +605,7 @@ let backoffBeforeRetry = async (
   let switchedToWorkingSource = if (
     retry >= failoverAfterRetries && (retry - failoverAfterRetries)->mod(2) === 0
   ) {
-    let now = Date.now()
+    let now = sourceManager.clock.now()
     sourceState.lastFailedAt = Some(now)
     switch sourceManager->getNextSource(~isRealtime, ~excludedSources?) {
     | Some(next) =>
@@ -851,8 +842,8 @@ let waitForNewBlock = (sourceManager: t, ~knownHeight, ~isRealtime, ~reducedPoll
     let cleanup = () => {
       watched->Array.forEach(subscription => subscription.unsubscribe())
       watched->Utils.Array.clearInPlace
-      pokeTimeoutId->Utils.clearTimeoutRef
-      stallTimeoutId->Utils.clearTimeoutRef
+      sourceManager.clock->Clock.clearRef(pokeTimeoutId)
+      sourceManager.clock->Clock.clearRef(stallTimeoutId)
     }
 
     let settled = ref(false)
@@ -922,32 +913,44 @@ let waitForNewBlock = (sourceManager: t, ~knownHeight, ~isRealtime, ~reducedPoll
       // Re-armed because distrusting a stream is a one-shot — the next height it
       // delivers takes it back at its word — and the silence that earned it can
       // come straight back.
-      let rec armPokeTimeout = () => pokeTimeoutId := Some(setTimeout(() => {
-              pokeTimeoutId := None
-              if !settled.contents {
-                watched->Array.forEach(subscription => subscription.distrustStream())
-              }
-
-              // Re-checked: distrusting can answer the wait, and a timer armed
-              // after the cleanup that follows is one nothing can ever clear.
-              if !settled.contents {
-                armPokeTimeout()
-              }
-            }, Utils.jitter(stallTimeout)))
+      let rec armPokeTimeout = () =>
+        pokeTimeoutId :=
+          Some(
+            sourceManager.clock.setTimeout(
+              ~label="stall poke",
+              () => {
+                pokeTimeoutId := None
+                if !settled.contents {
+                  watched->Array.forEach(subscription => subscription.distrustStream())
+                }
+
+                // Re-checked: distrusting can answer the wait, and a timer armed
+                // after the cleanup that follows is one nothing can ever clear.
+                if !settled.contents {
+                  armPokeTimeout()
+                }
+              },
+              sourceManager.clock->Clock.jitter(stallTimeout),
+            ),
+          )
 
       // Punctual, unlike the poke above: newBlockStallTimeout is a promise to the
       // operator about when they hear about a quiet chain, and spreading that
       // would report it early. Fires once — the warning is worth saying once per
       // wait, and a fallback stays recruited.
-      let armStallTimeout = () => stallTimeoutId := Some(setTimeout(() => {
-              stallTimeoutId := None
-              if !settled.contents {
-                stalled := true
-
-                // Build fallback: non-disabled sources not in mainSources with a valid role, even with recent lastFailedAt
-                let fallbackSources = []
-                sourcesState->Array.forEach(
-                  sourceState => {
+      let armStallTimeout = () =>
+        stallTimeoutId :=
+          Some(
+            sourceManager.clock.setTimeout(
+              ~label="stall timeout",
+              () => {
+                stallTimeoutId := None
+                if !settled.contents {
+                  stalled := true
+
+                  // Build fallback: non-disabled sources not in mainSources with a valid role, even with recent lastFailedAt
+                  let fallbackSources = []
+                  sourcesState->Array.forEach(sourceState => {
                     if (
                       !sourceState.disabled &&
                       !(mainSources->Array.includes(sourceState)) &&
@@ -959,37 +962,41 @@ let waitForNewBlock = (sourceManager: t, ~knownHeight, ~isRealtime, ~reducedPoll
                     ) {
                       fallbackSources->Array.push(sourceState)
                     }
-                  },
-                )
-
-                switch fallbackSources {
-                | [] =>
-                  logger->Logger.warn(
-                    `No new blocks detected within ${(stallTimeout / 1000)
-                        ->Int.toString}s. Polling will continue at a reduced rate. For better reliability, refer to our RPC fallback guide: https://docs.envio.dev/docs/HyperIndex/rpc-sync`,
+                  })
+
+                  switch fallbackSources {
+                  | [] =>
+                    logger->Logger.warn(
+                      `No new blocks detected within ${(stallTimeout / 1000)
+                          ->Int.toString}s. Polling will continue at a reduced rate. For better reliability, refer to our RPC fallback guide: https://docs.envio.dev/docs/HyperIndex/rpc-sync`,
+                    )
+                  | _ =>
+                    logger->Logger.warn(
+                      `No new blocks detected within ${(stallTimeout / 1000)
+                          ->Int.toString}s. Continuing polling with secondary RPC sources from the configuration.`,
+                    )
+                  }
+
+                  // Recruited to poll, not to stream: see `watch`.
+                  fallbackSources->Array.forEach(sourceState =>
+                    sourceState->watch(~withStream=false)
                   )
-                | _ =>
-                  logger->Logger.warn(
-                    `No new blocks detected within ${(stallTimeout / 1000)
-                        ->Int.toString}s. Continuing polling with secondary RPC sources from the configuration.`,
-                  )
-                }
 
-                // Recruited to poll, not to stream: see `watch`.
-                fallbackSources->Array.forEach(sourceState => sourceState->watch(~withStream=false))
-
-                // A fallback recruited here can still be holding a stream from an
-                // earlier wait that made it a primary, and a live stream is not
-                // polled behind. It has to inherit the verdict the primaries
-                // already earned — this wait has heard nothing for a whole window
-                // — or it would sit silent behind that stream until the next
-                // spread poke. Distrusting a waiter that already does so is a
-                // no-op, so this reaches the new ones only.
-                if !settled.contents {
-                  watched->Array.forEach(subscription => subscription.distrustStream())
+                  // A fallback recruited here can still be holding a stream from an
+                  // earlier wait that made it a primary, and a live stream is not
+                  // polled behind. It has to inherit the verdict the primaries
+                  // already earned — this wait has heard nothing for a whole window
+                  // — or it would sit silent behind that stream until the next
+                  // spread poke. Distrusting a waiter that already does so is a
+                  // no-op, so this reaches the new ones only.
+                  if !settled.contents {
+                    watched->Array.forEach(subscription => subscription.distrustStream())
+                  }
                 }
-              }
-            }, stallTimeout))
+              },
+              stallTimeout,
+            ),
+          )
 
       armPokeTimeout()
       armStallTimeout()

package/src/sources/SourceManager.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Clock from "../Clock.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Logger from "../Logger.res.mjs";
 import * as Source from "./Source.res.mjs";
@@ -153,7 +154,7 @@ function inFlightCount(sourceManager) {
 function getRateLimitTimeMs(sourceManager) {
   let startMs = sourceManager.activeRateLimitStartMs;
   return sourceManager.committedRateLimitTimeMs + (
-    startMs !== undefined ? Date.now() - startMs : 0.0
+    startMs !== undefined ? sourceManager.clock.now() - startMs : 0.0
   );
 }
 
@@ -162,14 +163,14 @@ function getRateLimitResetInMs(sourceManager) {
   if (resetAt === undefined) {
     return;
   }
-  let remaining = resetAt - Date.now();
+  let remaining = resetAt - sourceManager.clock.now();
   if (remaining > 0.0) {
     return remaining;
   }
 }
 
 function startRateLimitTimeout(sourceManager, resetMs) {
-  let now = Date.now();
+  let now = sourceManager.clock.now();
   if (sourceManager.rateLimitWaiters === 0) {
     sourceManager.activeRateLimitStartMs = now;
   }
@@ -186,20 +187,15 @@ async function waitForRateLimitReset(sourceManager, resetMs, retry, logger) {
     retry: retry,
     waitMs: waitMs
   });
-  let waitedAt = Date.now();
   startRateLimitTimeout(sourceManager, waitMs);
-  await Utils.delay(waitMs);
-  let short = waitedAt + waitMs - Date.now();
-  if (short > 0) {
-    await Utils.delay(Math.ceil(short) | 0);
-  }
+  await Clock.delay(sourceManager.clock, "rate-limit reset", waitMs);
   sourceManager.rateLimitWaiters = sourceManager.rateLimitWaiters - 1 | 0;
   if (sourceManager.rateLimitWaiters !== 0) {
     return;
   }
   let startMs = sourceManager.activeRateLimitStartMs;
   if (startMs !== undefined) {
-    sourceManager.committedRateLimitTimeMs = sourceManager.committedRateLimitTimeMs + Date.now() - startMs;
+    sourceManager.committedRateLimitTimeMs = sourceManager.committedRateLimitTimeMs + sourceManager.clock.now() - startMs;
     sourceManager.activeRateLimitStartMs = undefined;
   }
   sourceManager.activeRateLimitResetAtMs = undefined;
@@ -278,6 +274,7 @@ function makeGetHeightRetryInterval(initialRetryInterval, backoffMultiplicative,
 
 function make(sources, logger, isRealtime, timingOpt) {
   let timing = timingOpt !== undefined ? timingOpt : ({});
+  let clock = Stdlib_Option.getOr(timing.clock, Clock.real);
   let newBlockStallTimeout = Stdlib_Option.getOr(timing.newBlockStallTimeout, 60000);
   let newBlockStallTimeoutRealtime = Stdlib_Option.getOr(timing.newBlockStallTimeoutRealtime, 20000);
   let stalledPollingInterval = Stdlib_Option.getOr(timing.stalledPollingInterval, 5000);
@@ -293,7 +290,7 @@ function make(sources, logger, isRealtime, timingOpt) {
       let requestStats = {};
       return {
         source: source,
-        feed: HeightFeed.make(source, logger, stats => recordStatsInto(requestStats, stats), getHeightRetryInterval$1, Stdlib_Option.getOr(timing.heightPollTimeout, 60000)),
+        feed: HeightFeed.make(source, logger, stats => recordStatsInto(requestStats, stats), getHeightRetryInterval$1, Stdlib_Option.getOr(timing.heightPollTimeout, 60000), clock),
         disabled: false,
         lastFailedAt: undefined,
         requestStats: requestStats
@@ -314,7 +311,7 @@ function make(sources, logger, isRealtime, timingOpt) {
     waitingLogged: false,
     fetchingPartitionsCount: 0,
     recoveryTimeout: recoveryTimeout,
-    retryBackoffScale: Stdlib_Option.getOr(timing.retryBackoffScale, 1),
+    clock: clock,
     disableReason: undefined,
     hasRealtime: hasRealtime,
     committedRateLimitTimeMs: 0.0,
@@ -422,7 +419,7 @@ function compareByOldestFailure(a, b) {
 }
 
 function getNextSources(sourceManager, isRealtime, excludedSources) {
-  let now = Date.now();
+  let now = sourceManager.clock.now();
   let workingPrimarySources = [];
   let allPrimarySources = [];
   let workingSecondarySources = [];
@@ -475,7 +472,7 @@ function getNextSource(sourceManager, isRealtime, excludedSources) {
 }
 
 function sleepBackoff(sourceManager, millis) {
-  return Utils.delay(millis * sourceManager.retryBackoffScale | 0);
+  return Clock.delay(sourceManager.clock, "retry backoff", millis);
 }
 
 async function backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime, backoffMillis, minBackoffMillisOpt, failoverAfterRetriesOpt, excludedSources) {
@@ -483,7 +480,7 @@ async function backoffBeforeRetry(sourceManager, sourceState, retry, isRealtime,
   let failoverAfterRetries = failoverAfterRetriesOpt !== undefined ? failoverAfterRetriesOpt : 2;
   let switchedToWorkingSource;
   if (retry >= failoverAfterRetries && (retry - failoverAfterRetries | 0) % 2 === 0) {
-    let now = Date.now();
+    let now = sourceManager.clock.now();
     sourceState.lastFailedAt = now;
     let next = getNextSource(sourceManager, isRealtime, excludedSources);
     if (next !== undefined) {
@@ -599,8 +596,8 @@ function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling)
     let cleanup = () => {
       watched.forEach(subscription => subscription.unsubscribe());
       Utils.$$Array.clearInPlace(watched);
-      Utils.clearTimeoutRef(pokeTimeoutId);
-      Utils.clearTimeoutRef(stallTimeoutId);
+      Clock.clearRef(sourceManager.clock, pokeTimeoutId);
+      Clock.clearRef(sourceManager.clock, stallTimeoutId);
     };
     let settled = {
       contents: false
@@ -648,7 +645,7 @@ function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling)
       return;
     }
     let armPokeTimeout = () => {
-      pokeTimeoutId.contents = Primitive_option.some(setTimeout(() => {
+      pokeTimeoutId.contents = Primitive_option.some(sourceManager.clock.setTimeout("stall poke", () => {
         pokeTimeoutId.contents = undefined;
         if (!settled.contents) {
           watched.forEach(subscription => subscription.distrustStream());
@@ -656,10 +653,10 @@ function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPolling)
         if (!settled.contents) {
           return armPokeTimeout();
         }
-      }, Utils.jitter(stallTimeout)));
+      }, Clock.jitter(sourceManager.clock, stallTimeout)));
     };
     let armStallTimeout = () => {
-      stallTimeoutId.contents = Primitive_option.some(setTimeout(() => {
+      stallTimeoutId.contents = Primitive_option.some(sourceManager.clock.setTimeout("stall timeout", () => {
         stallTimeoutId.contents = undefined;
         if (settled.contents) {
           return;

package/src/sources/SourceManager.resi

@@ -17,11 +17,10 @@ type timing = {
   reducedPollingInterval?: int,
   recoveryTimeout?: float,
   getHeightRetryInterval?: (~retry: int) => int,
-  // Multiplies the sleep before retrying an items query or a block-hash
-  // lookup, but not the backoff it logs. A rate limit's wait is the server's
-  // to set and isn't scaled.
-  retryBackoffScale?: float,
   heightPollTimeout?: int,
+  // Every timer the manager and its height feeds arm, and every time they
+  // read. A test passes one that only moves when the test advances it.
+  clock?: Clock.t,
 }
 
 let make: (~sources: array<Source.t>, ~logger: Logger.t, ~isRealtime: bool, ~timing: timing=?) => t

package/src/sources/StartBlockResolver.res

@@ -25,6 +25,7 @@ let makeProbeSources = (chainConfig: Config.chain, ~logger, ~lowercaseAddresses)
     ~blockStore=BlockStore.make(~ecosystem=chainConfig.ecosystem),
     ~transactionStore=TransactionStore.make(~ecosystem=chainConfig.ecosystem),
     ~logger,
+    ~maxAddressesPerRequest=Env.maxAddrInPartition,
   )
 }
 

package/src/sources/StartBlockResolver.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Env from "../Env.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Logger from "../Logger.res.mjs";
 import * as ChainId from "../ChainId.res.mjs";
@@ -14,7 +15,7 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 
 function makeProbeSources(chainConfig, logger, lowercaseAddresses) {
   let addressStore = AddressStore.make(chainConfig.ecosystem, []);
-  return ChainSources.make(chainConfig, [], undefined, addressStore, lowercaseAddresses, BlockStore.make(chainConfig.ecosystem), TransactionStore.make(chainConfig.ecosystem), logger);
+  return ChainSources.make(chainConfig, [], undefined, addressStore, lowercaseAddresses, BlockStore.make(chainConfig.ecosystem), TransactionStore.make(chainConfig.ecosystem), logger, Env.maxAddrInPartition);
 }
 
 function candidateSources(sources) {
@@ -132,4 +133,4 @@ export {
   resolveHeadOrThrow,
   resolveAllOrThrow,
 }
-/* Utils Not a pure module */
+/* Env Not a pure module */

package/src/sources/SvmHyperSyncSource.res

@@ -277,7 +277,7 @@ let make = (
       {height, requestStats: [{method: "getHeight", seconds}]}
     },
     getItemsOrThrow,
-    createHeightSubscription: (~onHeight, ~onStatus) =>
-      HyperSyncSSE.subscribe(~hyperSyncUrl=endpointUrl, ~apiToken, ~onHeight, ~onStatus),
+    createHeightSubscription: (~clock, ~onHeight, ~onStatus) =>
+      HyperSyncSSE.subscribe(~clock, ~hyperSyncUrl=endpointUrl, ~apiToken, ~onHeight, ~onStatus),
   }
 }

package/src/sources/SvmHyperSyncSource.res.mjs

@@ -205,7 +205,7 @@ function make(param) {
       };
     },
     getItemsOrThrow: getItemsOrThrow,
-    createHeightSubscription: (onHeight, onStatus) => HyperSyncSSE.subscribe(endpointUrl, apiToken, onHeight, onStatus)
+    createHeightSubscription: (clock, onHeight, onStatus) => HyperSyncSSE.subscribe(clock, endpointUrl, apiToken, onHeight, onStatus)
   };
 }
 

package/svm.schema.json

@@ -219,6 +219,15 @@
           "format": "uint32",
           "minimum": 0
         },
+        "block_throttle": {
+          "description": "Once caught up, wait for this many new slots before fetching them. Delays new instructions by up to as many slots.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint32",
+          "minimum": 0
+        },
         "hypersync_config": {
           "description": "HyperSync Config for fetching historical instructions on this chain. Optional for the `solana` and `solana-devnet` chain ids, which default to their public HyperSync endpoints; required for any other chain id.",
           "anyOf": [
@@ -294,7 +303,7 @@
       "type": "object",
       "properties": {
         "name": {
-          "description": "A unique project-wide name for this program (used in generated code).",
+          "description": "A unique project-wide name for this program (used in the generated types).",
           "type": "string"
         },
         "program_id": {
@@ -348,7 +357,7 @@
       "type": "object",
       "properties": {
         "name": {
-          "description": "Name of the instruction in the HyperIndex generated code. Should be unique per program.",
+          "description": "Name of the instruction in the generated types. Should be unique per program.",
           "type": "string"
         },
         "discriminator": {

package/src/PgWriting.res

@@ -1,36 +0,0 @@
-let columns = (fields: array<Table.field>, ~kinds: array<Staging.kind>): array<Staging.column> =>
-  fields->Array.mapWithIndex((field, index) => {
-    Staging.name: field->Table.getPgDbFieldName,
-    kind: kinds->Array.getUnsafe(index),
-    isNullable: field.isNullable,
-  })
-
-// Lays a batch into the arena, column by column. The values are the ones the
-// table's own schema produced — a bigint as its digits, a date as its text, a
-// boolean as the number the statement's cast expects — so nothing here has to
-// know what a column means, only where its values go.
-//
-// The rows of a column are written in order because a variable-width slot's row
-// starts where the row before it ended.
-let stage = (
-  arena,
-  ~table,
-  ~columns: array<Staging.column>,
-  ~values: array<array<unknown>>,
-  ~rows,
-) => {
-  let stage = arena->Staging.begin(~table, ~rows, ~columns)
-  try {
-    for column in 0 to columns->Array.length - 1 {
-      let values = values->Array.getUnsafe(column)
-      for row in 0 to rows - 1 {
-        stage->Staging.writeValue(~column, ~row, values->Array.getUnsafe(row))
-      }
-    }
-    stage->Staging.commit
-  } catch {
-  | exn =>
-    stage->Staging.abort
-    throw(exn)
-  }
-}

package/src/PgWriting.res.mjs

@@ -1,34 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Table from "./db/Table.res.mjs";
-import * as Staging from "./Staging.res.mjs";
-
-function columns(fields, kinds) {
-  return fields.map((field, index) => ({
-    name: Table.getPgDbFieldName(field),
-    kind: kinds[index],
-    isNullable: field.isNullable
-  }));
-}
-
-function stage(arena, table, columns, values, rows) {
-  let stage$1 = Staging.begin(arena, table, rows, columns);
-  try {
-    for (let column = 0, column_finish = columns.length; column < column_finish; ++column) {
-      let values$1 = values[column];
-      for (let row = 0; row < rows; ++row) {
-        Staging.writeValue(stage$1, column, row, values$1[row]);
-      }
-    }
-    return Staging.commit(stage$1);
-  } catch (exn) {
-    Staging.abort(stage$1);
-    throw exn;
-  }
-}
-
-export {
-  columns,
-  stage,
-}
-/* Table Not a pure module */

package/src/db/IndexDefinition.res

@@ -1,47 +0,0 @@
-// What the indexer wants an index to be: a table, its ordered key columns with
-// their directions, and an access method. The addon names it, matches it
-// against what PostgreSQL holds and builds it.
-
-type column = {
-  name: string,
-  direction: Table.indexFieldDirection,
-}
-
-type t = {
-  tableName: string,
-  columns: array<column>,
-  method: string,
-}
-
-let make = (~tableName, ~columns) => {tableName, columns, method: "btree"}
-
-let single = (~tableName, ~column) =>
-  make(~tableName, ~columns=[{name: column, direction: Table.Asc}])
-
-let fromIndexFields = (~tableName, ~indexFields: array<Table.compositeIndexField>) =>
-  make(
-    ~tableName,
-    ~columns=indexFields->Array.map(({fieldName, direction}) => {name: fieldName, direction}),
-  )
-
-let toInput = ({tableName, columns, method}: t): Core.pgIndexInput => {
-  tableName,
-  columns: columns->Array.map(({name, direction}): Core.pgIndexColumnInput => {
-    name,
-    direction: switch direction {
-    | Table.Asc => "Asc"
-    | Desc => "Desc"
-    },
-  }),
-  method,
-}
-
-let describe = (definition: t) =>
-  `${definition.tableName}(${definition.columns
-    ->Array.map(({name, direction}) =>
-      switch direction {
-      | Asc => name
-      | Desc => `${name} DESC`
-      }
-    )
-    ->Array.joinUnsafe(", ")}) using ${definition.method}`