@reventlessdev/reventless-local 3.0.0-alpha.113

package/src/adapter/QueryDb/SortKey_Filter.res.mjs

@@ -0,0 +1,46 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function getSk(item, skField) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), d => d[skField]), Stdlib_JSON.Decode.string), "");
+}
+
+function apply(items, skField, prefix, from, to_, eq, reverseOpt, limit, offsetOpt) {
+  let reverse = reverseOpt !== undefined ? reverseOpt : false;
+  let offset = offsetOpt !== undefined ? offsetOpt : 0;
+  let filtered = items.filter(item => {
+    let sk = getSk(item, skField);
+    let okPrefix = Stdlib_Option.getOr(Stdlib_Option.map(prefix, p => sk.startsWith(p)), true);
+    let okFrom = Stdlib_Option.getOr(Stdlib_Option.map(from, f => sk >= f), true);
+    let okTo = Stdlib_Option.getOr(Stdlib_Option.map(to_, t => sk <= t), true);
+    let okEq = Stdlib_Option.getOr(Stdlib_Option.map(eq, e => sk === e), true);
+    if (okPrefix && okFrom && okTo) {
+      return okEq;
+    } else {
+      return false;
+    }
+  });
+  let ordered = reverse ? filtered.toReversed() : filtered;
+  let sliced = ordered.slice(offset, ordered.length);
+  let match = limit !== undefined ? [
+      sliced.slice(0, limit),
+      sliced.length > limit
+    ] : [
+      sliced,
+      false
+    ];
+  let page = match[0];
+  let nextToken = match[1] ? (offset + page.length | 0).toString() : undefined;
+  return {
+    items: page,
+    nextToken: nextToken
+  };
+}
+
+export {
+  getSk,
+  apply,
+}
+/* No side effect */

package/src/adapter/QueryEngine/LocalQueryEngine.res

@@ -0,0 +1,57 @@
+// In-memory QueryEngine — uses Bus storage registry for real scan/query.
+// This is a Make(Bus) functor; callers must first create
+//   module QueryEngine = LocalQueryEngine.Make(Bus)
+// and then pass QueryEngine as QueryEngineAdapter to Plugin_Builder.Make or Platform_Admin.Make.
+
+open Reventless
+
+module Make = (Bus: LocalBus.T) => {
+  let valueToString = value =>
+    switch value {
+    | QueryEngine.String(s) => s
+    | QueryEngine.Int(i) => i->Int.toString
+    | QueryEngine.Bool(b) => b ? "true" : "false"
+    }
+
+  let make: ReventlessCore.QueryDb_Adapter.queryEngineMaker = _allQueryDbs =>
+    Pulumi.Output.make({
+      QueryEngine.scan: async (~readModelName, ~filterConfigs as _, ~limit) =>
+        switch Bus.getQueryDbStream(readModelName) {
+        | Some(makeStream) =>
+          await makeStream()->Stream.take(limit)->Stream.runCollect->Effect.runPromise
+        | None =>
+          // Backward compat: fall back to array scan if no stream registered
+          switch Bus.getQueryDbScan(readModelName) {
+          | Some(scanAll) => scanAll()
+          | None => []
+          }
+        },
+      query: async (
+        ~readModelName,
+        ~key=?,
+        ~id,
+        ~subIdConfig as _=?,
+        ~filterConfigs as _=?,
+        ~ascending as _=?,
+        ~limit=?,
+      ) => {
+        let keyStr = switch key {
+        | Some(k) => k
+        | None => id->valueToString
+        }
+        switch Bus.getQueryDb(readModelName) {
+        | Some(ops) =>
+          let stream = ops.loadStream(keyStr)
+          let bounded = switch limit {
+          | Some(n) => stream->Stream.take(n)
+          | None => stream
+          }
+          await bounded
+          ->Stream.runCollect
+          ->Effect.catchAll(_ => Effect.succeed([]))
+          ->Effect.runPromise
+        | None => []
+        }
+      },
+    })
+}

package/src/adapter/QueryEngine/LocalQueryEngine.res.mjs

@@ -0,0 +1,56 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+
+function Make(Bus) {
+  let valueToString = value => {
+    switch (value.TAG) {
+      case "String" :
+        return value._0;
+      case "Int" :
+        return value._0.toString();
+      case "Bool" :
+        if (value._0) {
+          return "true";
+        } else {
+          return "false";
+        }
+    }
+  };
+  let make = _allQueryDbs => Pulumi.output({
+    scan: async (readModelName, param, limit) => {
+      let makeStream = Bus.getQueryDbStream(readModelName);
+      if (makeStream !== undefined) {
+        return await Effect.runPromise(Stream.runCollect(Stream$1.take(makeStream(), limit)));
+      }
+      let scanAll = Bus.getQueryDbScan(readModelName);
+      if (scanAll !== undefined) {
+        return scanAll();
+      } else {
+        return [];
+      }
+    },
+    query: async (readModelName, key, id, param, param$1, param$2, limit) => {
+      let keyStr = key !== undefined ? key : valueToString(id);
+      let ops = Bus.getQueryDb(readModelName);
+      if (ops === undefined) {
+        return [];
+      }
+      let stream = ops.loadStream(keyStr);
+      let bounded = limit !== undefined ? Stream$1.take(stream, limit) : stream;
+      return await Effect.runPromise(Effect.catchAll(Stream.runCollect(bounded), param => Effect.succeed([])));
+    }
+  });
+  return {
+    valueToString: valueToString,
+    make: make
+  };
+}
+
+export {
+  Make,
+}
+/* Stream Not a pure module */

package/src/adapter/Runtime/LocalAggregateRuntime_Builder.res

@@ -0,0 +1,91 @@
+// In-memory aggregate runtime builder.
+// Instead of creating Lambda functions and SQS/DynamoDB event source mappings,
+// wires handlers directly via the in-memory bus.
+
+module Make = (
+  Bus: LocalBus.T,
+  CommandTopicChannel: ReventlessCore.CommandTopic_Adapter.Channel
+    with type runtimeParts = LocalRuntimeEnvironment.parts,
+  EventCollectorChannel: ReventlessCore.EventCollector_Adapter.Channel
+    with type runtimeParts = LocalRuntimeEnvironment.parts,
+): (
+  ReventlessCore.AggregateRuntime_Builder.T
+    with type context = LocalRuntimeEnvironment.context
+    and type runtimeParts = LocalRuntimeEnvironment.parts
+    and module CommandTopicChannel = CommandTopicChannel
+    and module EventCollectorChannel = EventCollectorChannel
+) => {
+  type context = LocalRuntimeEnvironment.context
+  type runtimeParts = LocalRuntimeEnvironment.parts
+  module CommandTopicChannel = CommandTopicChannel
+  module EventCollectorChannel = EventCollectorChannel
+
+  let forCommandGenerator = (
+    ~handler,
+    ~connect,
+    ~memorySize as _=?,
+    ~timeout as _=?,
+    commandGenerator,
+  ) => {
+    // Call connect(~runtime) so CommandGeneratorResolvers_GraphQL.make registers SDL+resolvers.
+    // The runtime's handlerRef is unused by the GraphQL resolver path, but we create a proper
+    // runtime so the type is satisfied and future callers that need handlerRef will work.
+    let resource = commandGenerator->ReventlessCore.Component.toPulumiResource
+    let runtime = LocalRuntimeEnvironment.make(
+      ~name=resource.name->ReventlessCore.ComponentType.nameOpt(
+        ReventlessCore.CommandGenerator.componentType,
+      ),
+      ~handler=handler->Pulumi.Output.apply(h =>
+        h->LocalRuntimeEnvironment.asEffectHandler->ReventlessCore.Runtime.runEffectHandler
+      ),
+    )
+    connect(~runtime)
+  }
+
+  let forCommandTopic = (
+    ~handler,
+    ~connect,
+    ~memorySize as _=?,
+    ~timeout as _=?,
+    commandTopic,
+  ) => {
+    let resource = commandTopic->ReventlessCore.Component.toPulumiResource
+    let runtime = LocalRuntimeEnvironment.make(
+      ~name=resource.name->ReventlessCore.ComponentType.nameOpt(ReventlessCore.CommandTopic.componentType),
+      ~handler=handler->Pulumi.Output.apply(h =>
+        h->LocalRuntimeEnvironment.asEffectHandler->ReventlessCore.Runtime.runEffectHandler
+      ),
+    )
+    connect(~runtime)
+  }
+
+  let forEventCollector = (
+    ~handler,
+    ~eventTopics,
+    ~resources,
+    ~memorySize as _=?,
+    ~timeout as _=?,
+    eventCollector,
+  ) => {
+    let resource = eventCollector->ReventlessCore.Component.toPulumiResource
+    let name =
+      resource.name->ReventlessCore.ComponentType.nameOpt(ReventlessCore.EventCollector.componentType)
+    let opts = {Pulumi.ComponentResource.parent: resource}
+    let runtime = LocalRuntimeEnvironment.make(
+      ~name,
+      ~handler=handler->Pulumi.Output.apply(h =>
+        h->LocalRuntimeEnvironment.asEffectHandler->ReventlessCore.Runtime.runEffectHandler
+      ),
+    )
+    let _connectResources = EventCollectorChannel.connect(
+      ~name,
+      ~channelSpecs=[
+        {channel: eventCollector->ReventlessCore.EventCollector_Adapter.channel, eventTopics, resources},
+      ],
+      ~runtime,
+      ~opts,
+    )
+  }
+
+  let finish = () => ()
+}

package/src/adapter/Runtime/LocalAggregateRuntime_Builder.res.mjs

@@ -0,0 +1,50 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Runtime$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Runtime/Runtime.res.mjs";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/src/ComponentType.res.mjs";
+import * as EventCollector$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventCollector/EventCollector.res.mjs";
+import * as CommandGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandGenerator/CommandGenerator.res.mjs";
+import * as LocalRuntimeEnvironment$ReventlessLocal from "./LocalRuntimeEnvironment.res.mjs";
+
+function Make(Bus) {
+  return CommandTopicChannel => (EventCollectorChannel => {
+    let forCommandGenerator = (handler, connect, param, param$1, commandGenerator) => {
+      let resource = Component$ReventlessCore.toPulumiResource(commandGenerator);
+      return connect(LocalRuntimeEnvironment$ReventlessLocal.make(ComponentType$ReventlessCore.nameOpt(resource.__name, CommandGenerator$ReventlessCore.componentType), handler.apply(Runtime$ReventlessCore.runEffectHandler), undefined, undefined, undefined));
+    };
+    let forCommandTopic = (handler, connect, param, param$1, commandTopic) => {
+      let resource = Component$ReventlessCore.toPulumiResource(commandTopic);
+      return connect(LocalRuntimeEnvironment$ReventlessLocal.make(ComponentType$ReventlessCore.nameOpt(resource.__name, CommandTopic$ReventlessCore.componentType), handler.apply(Runtime$ReventlessCore.runEffectHandler), undefined, undefined, undefined));
+    };
+    let forEventCollector = (handler, eventTopics, resources, param, param$1, eventCollector) => {
+      let resource = Component$ReventlessCore.toPulumiResource(eventCollector);
+      let name = ComponentType$ReventlessCore.nameOpt(resource.__name, EventCollector$ReventlessCore.componentType);
+      let opts_parent = resource;
+      let opts = {
+        parent: opts_parent
+      };
+      let runtime = LocalRuntimeEnvironment$ReventlessLocal.make(name, handler.apply(Runtime$ReventlessCore.runEffectHandler), undefined, undefined, undefined);
+      EventCollectorChannel.connect(name, [{
+          channel: eventCollector.channel,
+          eventTopics: eventTopics,
+          resources: resources
+        }], runtime, opts);
+    };
+    let finish = () => {};
+    return {
+      CommandTopicChannel: CommandTopicChannel,
+      EventCollectorChannel: EventCollectorChannel,
+      forCommandGenerator: forCommandGenerator,
+      forCommandTopic: forCommandTopic,
+      forEventCollector: forEventCollector,
+      finish: finish
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* Runtime-ReventlessCore Not a pure module */

package/src/adapter/Runtime/LocalEventCollectorRuntime_Builder.res

@@ -0,0 +1,47 @@
+// In-memory EventCollector runtime builder.
+// Wires event collectors directly via the in-memory bus instead of Lambda + DynamoDB streams.
+
+module Make = (
+  Bus: LocalBus.T,
+  EventCollectorChannel: ReventlessCore.EventCollector_Adapter.Channel
+    with type runtimeParts = LocalRuntimeEnvironment.parts,
+): (
+  ReventlessCore.EventCollectorRuntime_Builder.T
+    with type context = LocalRuntimeEnvironment.context
+    and type runtimeParts = LocalRuntimeEnvironment.parts
+    and module EventCollectorChannel = EventCollectorChannel
+) => {
+  type context = LocalRuntimeEnvironment.context
+  type runtimeParts = LocalRuntimeEnvironment.parts
+  module EventCollectorChannel = EventCollectorChannel
+
+  let forEventCollector = (
+    ~handler,
+    ~eventTopics,
+    ~resources,
+    ~memorySize as _=?,
+    ~timeout as _=?,
+    eventCollector,
+  ) => {
+    let resource = eventCollector->ReventlessCore.Component.toPulumiResource
+    let name =
+      resource.name->ReventlessCore.ComponentType.nameOpt(ReventlessCore.EventCollector.componentType)
+    let opts = {Pulumi.ComponentResource.parent: resource}
+    let runtime = LocalRuntimeEnvironment.make(
+      ~name,
+      ~handler=handler->Pulumi.Output.apply(h =>
+        h->LocalRuntimeEnvironment.asEffectHandler->ReventlessCore.Runtime.runEffectHandler
+      ),
+    )
+    let _connectResources = EventCollectorChannel.connect(
+      ~name,
+      ~channelSpecs=[
+        {channel: eventCollector->ReventlessCore.EventCollector_Adapter.channel, eventTopics, resources},
+      ],
+      ~runtime,
+      ~opts,
+    )
+  }
+
+  let finish = () => ()
+}

package/src/adapter/Runtime/LocalEventCollectorRuntime_Builder.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Runtime$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Runtime/Runtime.res.mjs";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/src/ComponentType.res.mjs";
+import * as EventCollector$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventCollector/EventCollector.res.mjs";
+import * as LocalRuntimeEnvironment$ReventlessLocal from "./LocalRuntimeEnvironment.res.mjs";
+
+function Make(Bus) {
+  return EventCollectorChannel => {
+    let forEventCollector = (handler, eventTopics, resources, param, param$1, eventCollector) => {
+      let resource = Component$ReventlessCore.toPulumiResource(eventCollector);
+      let name = ComponentType$ReventlessCore.nameOpt(resource.__name, EventCollector$ReventlessCore.componentType);
+      let opts_parent = resource;
+      let opts = {
+        parent: opts_parent
+      };
+      let runtime = LocalRuntimeEnvironment$ReventlessLocal.make(name, handler.apply(Runtime$ReventlessCore.runEffectHandler), undefined, undefined, undefined);
+      EventCollectorChannel.connect(name, [{
+          channel: eventCollector.channel,
+          eventTopics: eventTopics,
+          resources: resources
+        }], runtime, opts);
+    };
+    let finish = () => {};
+    return {
+      EventCollectorChannel: EventCollectorChannel,
+      forEventCollector: forEventCollector,
+      finish: finish
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* Runtime-ReventlessCore Not a pure module */

package/src/adapter/Runtime/LocalPluginRuntime_Builder.res

@@ -0,0 +1,11 @@
+// In-memory PluginRuntime builder.
+// Wraps PluginRuntime_Builder_Micro with LocalRuntimeEnvironment and LocalEventCollectorChannel.
+
+module Make = (Bus: LocalBus.T) => {
+  module ECChannel = LocalEventCollectorChannel.Make(Bus)
+
+  include ReventlessCore.PluginRuntime_Builder_Micro.Make(
+    LocalRuntimeEnvironment,
+    ECChannel,
+  )
+}

package/src/adapter/Runtime/LocalPluginRuntime_Builder.res.mjs

@@ -0,0 +1,30 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as LocalRuntimeEnvironment$ReventlessLocal from "./LocalRuntimeEnvironment.res.mjs";
+import * as LocalEventCollectorChannel$ReventlessLocal from "../EventCollector/LocalEventCollectorChannel.res.mjs";
+import * as PluginRuntime_Builder_Micro$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Runtime/PluginRuntime_Builder_Micro.res.mjs";
+
+function Make(Bus) {
+  let ECChannel = LocalEventCollectorChannel$ReventlessLocal.Make(Bus);
+  let include = PluginRuntime_Builder_Micro$ReventlessCore.Make({
+    make: LocalRuntimeEnvironment$ReventlessLocal.make,
+    groupBySource: LocalRuntimeEnvironment$ReventlessLocal.groupBySource,
+    extractCorrelationId: LocalRuntimeEnvironment$ReventlessLocal.extractCorrelationId,
+    asEventHandler: prim => prim,
+    asEffectHandler: prim => prim
+  })(ECChannel);
+  return {
+    ECChannel: ECChannel,
+    EventCollectorChannel: include.EventCollectorChannel,
+    registerPluginName: include.registerPluginName,
+    forPluginEventCollector: include.forPluginEventCollector,
+    forPluginHeartbeat: include.forPluginHeartbeat,
+    forDcbCommandTopic: include.forDcbCommandTopic,
+    finish: include.finish
+  };
+}
+
+export {
+  Make,
+}
+/* LocalRuntimeEnvironment-ReventlessLocal Not a pure module */

package/src/adapter/Runtime/LocalRuntimeEnvironment.res

@@ -0,0 +1,54 @@
+// In-memory runtime environment.
+// Instead of creating Lambda functions, stores the handler in a Deferred so consumers
+// block until the handler is registered — eliminating the ref<option> race condition.
+//
+// subscriptionLatch is opened by EventCollectorChannel.connect once subscriptions are
+// registered. Callers can await it before publishing to guarantee delivery.
+
+type event = JSON.t
+type context = unit
+type handler = (JSON.t, unit) => promise<unit>
+type parts = {
+  handlerDeferred: Deferred.t<handler, unit>,
+  subscriptionLatch: Latch.t,
+}
+
+// Coerce a polymorphic handler to return promise<unit> so we can call it from the bus.
+// The return value is discarded — we only await for side effects.
+external asUnitHandler: ((JSON.t, unit) => promise<'r>) => (JSON.t, unit) => promise<unit> =
+  "%identity"
+
+let make = (
+  ~name as _: string,
+  ~handler: Pulumi.Output.t<ReventlessCore.Runtime.eventHandler<event, context, 'result>>,
+  ~memorySize as _=1024,
+  ~timeout as _=30,
+  ~opts as _=?,
+): ReventlessCore.Runtime.environment<parts> => {
+  let handlerDeferred = Deferred.make()->Effect.runSync
+  let subscriptionLatch = Effect.makeLatch(false)->Effect.runSync
+  // In Pulumi mock mode, Output.apply resolves in ~2 microtask ticks.
+  // Use runPromise (not runSync) so fiber wake-ups are properly scheduled.
+  let _ = handler->Pulumi.Output.apply(h => {
+    Deferred.succeed(handlerDeferred, h->asUnitHandler)->Effect.runPromise->ignore
+  })
+  {parts: {handlerDeferred, subscriptionLatch}, resources: []}
+}
+
+let groupBySource = (event: JSON.t) => {
+  let dict: dict<JSON.t> = Dict.make()
+  dict->Dict.set("inmemory", event)
+  dict
+}
+
+let extractCorrelationId = (event: event) =>
+  event
+  ->JSON.Decode.object
+  ->Option.flatMap(obj => obj->Dict.get("meta"))
+  ->Option.flatMap(JSON.Decode.object)
+  ->Option.flatMap(meta => meta->Dict.get("correlationId"))
+  ->Option.flatMap(JSON.Decode.string)
+
+external asEventHandler: 'a => ReventlessCore.Runtime.eventHandler<event, context, 'r> = "%identity"
+external asEffectHandler: 'a => ReventlessCore.Runtime.effectHandler<event, context, 'r, 'error> =
+  "%identity"

package/src/adapter/Runtime/LocalRuntimeEnvironment.res.mjs

@@ -0,0 +1,40 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Deferred from "effect/Deferred";
+
+function make(param, handler, $staropt$star, $staropt$star$1, param$1) {
+  $staropt$star !== undefined;
+  $staropt$star$1 !== undefined;
+  let handlerDeferred = Effect.runSync(Deferred.make());
+  let subscriptionLatch = Effect.runSync(Effect.makeLatch(false));
+  handler.apply(h => {
+    Effect.runPromise(Deferred.succeed(handlerDeferred, h));
+  });
+  return {
+    parts: {
+      handlerDeferred: handlerDeferred,
+      subscriptionLatch: subscriptionLatch
+    },
+    resources: []
+  };
+}
+
+function groupBySource(event) {
+  let dict = {};
+  dict["inmemory"] = event;
+  return dict;
+}
+
+function extractCorrelationId(event) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(event), obj => obj["meta"]), Stdlib_JSON.Decode.object), meta => meta["correlationId"]), Stdlib_JSON.Decode.string);
+}
+
+export {
+  make,
+  groupBySource,
+  extractCorrelationId,
+}
+/* effect/Effect Not a pure module */

package/src/adapter/Scheduler/LocalScheduledPublisher.res

@@ -0,0 +1,102 @@
+// In-memory ScheduledPublisher — satisfies Scheduler_Adapter.ScheduledPublisher.
+//
+// createSchedule: sets up a setInterval that fires Bus.publishEvent when the schedule triggers.
+// deleteSchedule: clears the interval.
+//
+// The schedule.payload is published as the event body. For Single(…) schedules a
+// one-shot setTimeout is used; all recurring rates use setInterval.
+//
+// Usage: create a Scheduler with Scheduler_Builder.Make(LocalScheduledPublisher.Make(Bus))
+// and pass the resulting component to Plugin_Builder or Task_Builder.
+
+module Make = (Bus: LocalBus.T) => {
+  type timerHandle
+
+  @val
+  external setIntervalJs: (unit => unit, int) => timerHandle = "setInterval"
+  @val
+  external setTimeoutJs: (unit => unit, int) => timerHandle = "setTimeout"
+  @val
+  external clearTimerJs: timerHandle => unit = "clearTimeout"
+
+  let activeTimers: ref<dict<timerHandle>> = ref(Dict.make())
+
+  let rateToMs = (rate: Reventless.Schedule.rate) =>
+    switch rate {
+    | Minutes(n) => n * 60 * 1000
+    | Hours(n) => n * 60 * 60 * 1000
+    | Days(n) => n * 24 * 60 * 60 * 1000
+    | Daily(_, _) => 24 * 60 * 60 * 1000
+    | Weekdays(_, _) => 24 * 60 * 60 * 1000
+    | WeekdaysAndSaturday(_, _) => 24 * 60 * 60 * 1000
+    | Single(_, _, _, _, _) => 0
+    }
+
+  let isSingleShot = rate =>
+    switch rate {
+    | Reventless.Schedule.Single(_, _, _, _, _) => true
+    | _ => false
+    }
+
+  let scheduleMeta: ReventlessCore.Message.meta = {
+    service: "Scheduler",
+    time: "",
+    ip: "",
+    user: "Scheduler",
+    msgId: "",
+    correlationId: "",
+  }
+
+  let make: ReventlessCore.Scheduler_Adapter.scheduledPublisherMaker = (~name as _, ~opts as _) => {
+    let createSchedule: ReventlessInfra.Scheduler.createSchedule = async (
+      channelResources,
+      schedule,
+    ) => {
+      let topicName = switch channelResources {
+      | [] => ""
+      | resources => (resources->Array.getUnsafe(0)).name
+      }
+      let payloadJson = switch schedule.payload->JSON.parseOrThrow {
+      | json => json
+      | exception _ => schedule.payload->JSON.Encode.string
+      }
+      let fire = () =>
+        Bus.publishEvent(topicName, "Scheduler", scheduleMeta, payloadJson)->ignore
+      let handle =
+        if schedule.rate->isSingleShot {
+          setTimeoutJs(fire, 0)
+        } else {
+          setIntervalJs(fire, rateToMs(schedule.rate))
+        }
+      activeTimers.contents->Dict.set(schedule.name, handle)
+    }
+
+    let deleteSchedule: ReventlessInfra.Scheduler.deleteSchedule = async (_, name) => {
+      switch activeTimers.contents->Dict.get(name) {
+      | Some(handle) =>
+        clearTimerJs(handle)
+        activeTimers.contents->Dict.delete(name)
+      | None => ()
+      }
+    }
+
+    {
+      resource: ReventlessInfra.Adapter.make(
+        ~name=""->Pulumi.Output.make,
+        ~id=""->Pulumi.Output.make,
+        ~urn=""->Pulumi.Output.make,
+        ~service="memory:InMemory"->Pulumi.Output.make,
+      ),
+      operations: ({
+        createSchedule,
+        deleteSchedule,
+      }: ReventlessInfra.Scheduler.operations)->Pulumi.Output.make,
+    }
+  }
+
+  // Clear all active timers — call in afterAll/afterEach for test isolation.
+  let reset = () => {
+    activeTimers.contents->Dict.valuesToArray->Array.forEach(clearTimerJs)
+    activeTimers.contents = Dict.make()
+  }
+}