@reventlessdev/reventless-aws 3.0.0-alpha.232 → 3.0.0-alpha.233

package/src/adapter/Runtime/EventMapperEntryPoint.mjs

@@ -1,21 +1,21 @@
 // EventMapper Lambda entry point (Micro mode).
 // At cold start: reads HANDLER_CONFIG, dynamically imports Target Spec and Mappings,
 // wires EventMapper_Callback.MakeCounterHandler + MakeEventCollectorHandler.
+//
+// Thin untyped shell ("typed core, thin shell" —
+// docs/plans/minimize-lambda-entrypoint-mjs-shell.md): this file owns ONLY the
+// seams that are inherently untyped — the dynamic `import()` of the
+// target-spec/mappings modules named in HANDLER_CONFIG, the shape fix-ups on
+// those runtime-loaded modules (patchSpecId / patchMappingsSourceIds), and the
+// MakeCounterHandler functor application consuming them. HANDLER_CONFIG
+// parsing, the publish/query operations, the MakeEventCollectorHandler
+// application, and the per-source dispatch boundary live type-checked in
+// EventMapperEntryPoint_Ops.res.
 
 import { $$String as IdString } from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
-import {
-  patchSpecId,
-  makeQueueRef,
-  log,
-  runEffect,
-  setRequestId,
-  extractMetaField,
-  extractSentTimestamp,
-  extractRetryCount,
-} from "./HandlerFactoryHelpers.mjs";
-import { MakeCounterHandler, MakeEventCollectorHandler } from "@reventlessdev/reventless-core/src/components/EventMapper/EventMapper_Callback.res.mjs";
-import { publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
-import { handleStreamEvent } from "@reventlessdev/reventless-aws/src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream_Runtime.res.mjs";
+import { patchSpecId } from "./HandlerFactoryHelpers.mjs";
+import { MakeCounterHandler } from "@reventlessdev/reventless-core/src/components/EventMapper/EventMapper_Callback.res.mjs";
+import * as Ops from "./EventMapperEntryPoint_Ops.res.mjs";
 
 const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
 
@@ -33,19 +33,8 @@ function patchMappingsSourceIds(mappingsModule) {
   };
 }
 
-function groupBySource(records) {
-  const dict = {};
-  records.forEach(record => {
-    const arn = record.eventSourceARN;
-    const existing = dict[arn] || [];
-    dict[arn] = existing.concat([record]);
-  });
-  return dict;
-}
-
-async function buildHandler() {
-  const configStr = process.env["HANDLER_CONFIG"] || "{}";
-  const config = JSON.parse(configStr);
+async function build() {
+  const config = Ops.parseHandlerConfig(process.env["HANDLER_CONFIG"] || "{}");
 
   const targetSpecModule = await dynamicImport(config.targetSpecModule);
   const mappingsModule = await dynamicImport(config.mappingsModule);
@@ -53,47 +42,14 @@ async function buildHandler() {
   const patchedTarget = patchSpecId(targetSpecModule);
   const patchedMappings = patchMappingsSourceIds(mappingsModule);
 
-  const publishJsons = sqsPublishJsons(makeQueueRef(config.queueUrl), "SQS_FIFO");
-  const queryEngine = {
-    query: async () => { log.error("queryEngine not available in bundled mode", { comp: "EventMapperEntryPoint" }); return []; },
-    get: async () => { log.error("queryEngine not available in bundled mode", { comp: "EventMapperEntryPoint" }); return undefined; },
-  };
+  const counterOps = Ops.makeCounterOps(config);
+  const counterHandler = MakeCounterHandler(patchedTarget)(patchedMappings)(counterOps);
 
-  const counterHandler = MakeCounterHandler(patchedTarget)(patchedMappings)({ publishJsons, queryEngine });
-  const noopAsync = async (_) => {};
-  const eventCollectorHandler = MakeEventCollectorHandler({
-    publishJsons,
-    count: noopAsync,
-    addToCounterTarget: noopAsync,
-    commonEventsHandler: counterHandler.commonEventsHandler,
-  });
-
-  return {
-    streamHandler: (event, context) =>
-      handleStreamEvent(eventCollectorHandler.handleJsonEvents, event, context),
-    // The mapper is named after the target it maps into.
-    comp: `EventMapper(${patchedTarget.name})`,
-  };
+  // The mapper is named after the target it maps into.
+  return [
+    Ops.makeStreamHandler(counterOps, counterHandler.commonEventsHandler),
+    `EventMapper(${patchedTarget.name})`,
+  ];
 }
 
-const initPromise = buildHandler();
-
-export async function handler(event, context) {
-  setRequestId(context?.awsRequestId);
-  const { streamHandler, comp } = await initPromise;
-  const records = event.Records || [];
-  const grouped = groupBySource(records);
-
-  await Promise.all(Object.entries(grouped).map(async ([arn, subRecords]) => {
-    log.debug("processing " + arn, { comp: "EventMapperRuntime" });
-    await runEffect(streamHandler({ Records: subRecords }, context), {
-      correlationId: extractMetaField(subRecords, "correlationId"),
-      causationId: extractMetaField(subRecords, "causationId"),
-      comp,
-      timestamp: extractSentTimestamp(subRecords),
-      retryCount: extractRetryCount(subRecords),
-    });
-  }));
-
-  return "";
-}
+export const handler = Ops.makeHandler(build());

package/src/adapter/Runtime/EventMapperEntryPoint_Ops.res

@@ -0,0 +1,126 @@
+// Typed cold-start core for the EventMapper Lambda entry point (Micro mode).
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md):
+// EventMapperEntryPoint.mjs keeps only the untyped seam — the dynamic
+// `import()` of the target-spec/mappings modules named in HANDLER_CONFIG, the
+// `patchSpecId` / mapping-Source-Id fix-ups, and the
+// EventMapper_Callback.MakeCounterHandler functor application consuming them.
+// HANDLER_CONFIG parsing, the publish/query operations, the
+// MakeEventCollectorHandler application (a functor over an inline module
+// capturing runtime values), and the per-source dispatch boundary live here,
+// fully type-checked.
+//
+// The former shell's queryEngine stub carried wrong field names
+// (`query`/`get` for QueryEngine.operations' `scan`/`query`) — a mapping
+// calling `scan` crashed with "not a function" instead of the intended
+// logged-error fallback. The typed record fixes the shape; both operations
+// still log an error and return [] (not available in the bundled handler).
+
+// ── HANDLER_CONFIG ──────────────────────────────────────────────────────────
+// Written by AggregateRuntime_Builder_Micro / _Micro_Async.
+
+type handlerConfig = {
+  targetSpecModule?: string,
+  mappingsModule?: string,
+  queueUrl?: string,
+}
+@val @scope("JSON") external jsonParse: string => handlerConfig = "parse"
+// A real binding (not a bare external) so the shell can import it.
+let parseHandlerConfig = (raw: string): handlerConfig => jsonParse(raw)
+
+// ── Counter-handler operations (third argument of MakeCounterHandler) ───────
+
+type counterOps = {
+  publishJsons: ReventlessCore.CommandTopic.publishJsons,
+  queryEngine: Reventless.QueryEngine.operations,
+}
+
+let makeCounterOps = (config: handlerConfig): counterOps => {
+  let queueUrl = config.queueUrl->Option.getOr("")
+  let queue: Util_SQS_Runtime.resolvedQueue = {id: queueUrl, name: queueUrl, arn: ""}
+  {
+    publishJsons: queue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO),
+    queryEngine: {
+      scan: async (~readModelName as _, ~filterConfigs as _, ~limit as _) => {
+        StreamRoutedEntryPoint_Ops.logError(
+          "queryEngine not available in bundled mode",
+          {comp: "EventMapperEntryPoint"},
+        )
+        []
+      },
+      query: async (
+        ~readModelName as _,
+        ~key as _=?,
+        ~id as _,
+        ~subIdConfig as _=?,
+        ~filterConfigs as _=?,
+        ~ascending as _=?,
+        ~limit as _=?,
+      ) => {
+        StreamRoutedEntryPoint_Ops.logError(
+          "queryEngine not available in bundled mode",
+          {comp: "EventMapperEntryPoint"},
+        )
+        []
+      },
+    },
+  }
+}
+
+// ── Stream handler ──────────────────────────────────────────────────────────
+// `commonEventsHandler` comes off the shell's MakeCounterHandler application
+// (it consumes the runtime-loaded target/mappings modules); everything it
+// feeds — counter no-ops, publishing, the stream wrap — is typed.
+
+type commonEventsHandler = array<JSON.t> => promise<(
+  promise<array<ReventlessCore.Message.commandJson>>,
+  array<ReventlessCore.Counter.action>,
+)>
+
+let makeStreamHandler = (
+  ops: counterOps,
+  commonEventsHandler: commonEventsHandler,
+): StreamRoutedEntryPoint_Ops.streamHandler => {
+  module Handler = ReventlessCore.EventMapper_Callback.MakeEventCollectorHandler({
+    let publishJsons = ops.publishJsons
+    let count: ReventlessCore.Counter.count = async _ => ()
+    let addToCounterTarget: ReventlessCore.Counter.addToCounterTarget = async _ => ()
+    let commonEventsHandler = commonEventsHandler
+  })
+  StreamRoutedEntryPoint_Ops.toStreamHandler(Handler.handleJsonEvents)
+}
+
+// ── Dispatch boundary ───────────────────────────────────────────────────────
+// Unlike the registry-routed entry points (one Lambda, many components), the
+// mapper Lambda serves a single target: every source group runs the same
+// handler, attributed `EventMapper(<Target>)`.
+
+let makeHandler = (
+  buildPromise: promise<(StreamRoutedEntryPoint_Ops.streamHandler, string)>,
+) =>
+  async (event: PulumiAws.Lambda.CallbackFunction.event, context: PulumiAws.Lambda.context) => {
+    StreamRoutedEntryPoint_Ops.setRequestId(context.awsRequestId)
+    let (streamHandler, comp) = await buildPromise
+    let _ =
+      await StreamRoutedEntryPoint_Ops.groupBySource(event.records)
+      ->Dict.toArray
+      ->Array.map(async ((arn, subRecords)) => {
+        StreamRoutedEntryPoint_Ops.logDebug("processing " ++ arn, {comp: "EventMapperRuntime"})
+        let subEvent: PulumiAws.Lambda.CallbackFunction.event = {records: subRecords}
+        await StreamRoutedEntryPoint_Ops.runEffect(
+          streamHandler(subEvent, context),
+          {
+            correlationId: ?StreamRoutedEntryPoint_Ops.extractMetaField(
+              subRecords,
+              "correlationId",
+            ),
+            causationId: ?StreamRoutedEntryPoint_Ops.extractMetaField(subRecords, "causationId"),
+            comp,
+            timestamp: ?StreamRoutedEntryPoint_Ops.extractSentTimestamp(subRecords),
+            retryCount: StreamRoutedEntryPoint_Ops.extractRetryCount(subRecords),
+          },
+        )
+      })
+      ->Promise.all
+    ""
+  }

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

@@ -0,0 +1,83 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as EventMapper_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventMapper/EventMapper_Callback.res.mjs";
+import * as StreamRoutedEntryPoint_Ops$ReventlessAws from "./StreamRoutedEntryPoint_Ops.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+
+function parseHandlerConfig(raw) {
+  return JSON.parse(raw);
+}
+
+function makeCounterOps(config) {
+  let queueUrl = Stdlib_Option.getOr(config.queueUrl, "");
+  let queue = {
+    id: queueUrl,
+    name: queueUrl,
+    arn: ""
+  };
+  return {
+    publishJsons: CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO"),
+    queryEngine: {
+      scan: async (param, param$1, param$2) => {
+        StreamRoutedEntryPoint_Ops$ReventlessAws.logError("queryEngine not available in bundled mode", {
+          comp: "EventMapperEntryPoint"
+        });
+        return [];
+      },
+      query: async (param, param$1, param$2, param$3, param$4, param$5, param$6) => {
+        StreamRoutedEntryPoint_Ops$ReventlessAws.logError("queryEngine not available in bundled mode", {
+          comp: "EventMapperEntryPoint"
+        });
+        return [];
+      }
+    }
+  };
+}
+
+function makeStreamHandler(ops, commonEventsHandler) {
+  let publishJsons = ops.publishJsons;
+  let count = async param => {};
+  let addToCounterTarget = async param => {};
+  let Handler = EventMapper_Callback$ReventlessCore.MakeEventCollectorHandler({
+    publishJsons: publishJsons,
+    count: count,
+    addToCounterTarget: addToCounterTarget,
+    commonEventsHandler: commonEventsHandler
+  });
+  return StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(Handler.handleJsonEvents);
+}
+
+function makeHandler(buildPromise) {
+  return async (event, context) => {
+    StreamRoutedEntryPoint_Ops$ReventlessAws.setRequestId(context.awsRequestId);
+    let match = await buildPromise;
+    let comp = match[1];
+    let streamHandler = match[0];
+    await Promise.all(Object.entries(StreamRoutedEntryPoint_Ops$ReventlessAws.groupBySource(event.Records)).map(async param => {
+      let subRecords = param[1];
+      StreamRoutedEntryPoint_Ops$ReventlessAws.logDebug("processing " + param[0], {
+        comp: "EventMapperRuntime"
+      });
+      let subEvent = {
+        Records: subRecords
+      };
+      return await StreamRoutedEntryPoint_Ops$ReventlessAws.runEffect(streamHandler(subEvent, context), {
+        correlationId: StreamRoutedEntryPoint_Ops$ReventlessAws.extractMetaField(subRecords, "correlationId"),
+        causationId: StreamRoutedEntryPoint_Ops$ReventlessAws.extractMetaField(subRecords, "causationId"),
+        comp: comp,
+        timestamp: StreamRoutedEntryPoint_Ops$ReventlessAws.extractSentTimestamp(subRecords),
+        retryCount: StreamRoutedEntryPoint_Ops$ReventlessAws.extractRetryCount(subRecords)
+      });
+    }));
+    return "";
+  };
+}
+
+export {
+  parseHandlerConfig,
+  makeCounterOps,
+  makeStreamHandler,
+  makeHandler,
+}
+/* EventMapper_Callback-ReventlessCore Not a pure module */

package/src/adapter/Runtime/ExtensionPointEntryPoint.mjs

@@ -2,84 +2,37 @@
 // At cold start: reads HANDLER_CONFIG, dynamically imports Spec/Mappings,
 // wires ExtensionPoint_Callback.Make + CommandTopic_Callback.Make,
 // routes SQS events through handleQueueEvent.
-
-import {
-  patchSpecId,
-  makeQueueRef,
-  log,
-  runEffect,
-  setRequestId,
-  extractMetaField,
-  extractSentTimestamp,
-  extractRetryCount,
-} from "./HandlerFactoryHelpers.mjs";
+//
+// Thin untyped shell ("typed core, thin shell" —
+// docs/plans/minimize-lambda-entrypoint-mjs-shell.md): this file owns ONLY the
+// seams that are inherently untyped — the dynamic `import()` of the
+// spec/mappings modules named in HANDLER_CONFIG, the `patchSpecId` fix-up, and
+// the two functor applications consuming them. The callback config,
+// HANDLER_CONFIG parsing, and the SQS dispatch boundary live type-checked in
+// ExtensionPointEntryPoint_Ops.res.
+
+import { patchSpecId } from "./HandlerFactoryHelpers.mjs";
 import { Make as extensionPointCallbackMake } from "@reventlessdev/reventless-core/src/components/ExtensionPoint/ExtensionPoint_Callback.res.mjs";
 import { Make as commandTopicCallbackMake } from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Callback.res.mjs";
-import { handleQueueEvent, publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+import * as Ops from "./ExtensionPointEntryPoint_Ops.res.mjs";
 
 const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
 
-async function buildHandler() {
-  const configStr = process.env["HANDLER_CONFIG"] || "{}";
-  const config = JSON.parse(configStr);
+async function build() {
+  const config = Ops.parseHandlerConfig(process.env["HANDLER_CONFIG"] || "{}");
 
   const specModule = await dynamicImport(config.specModule);
   const mappingsModule = await dynamicImport(config.mappingsModule);
 
   const patchedSpec = patchSpecId(specModule);
 
-  // Build publishToAggregates dict from env var queue URLs. The deploy-side
-  // builder writes HANDLER_CONFIG.publishToAggregates as { aggregateName: envVarName }
-  // (see ExtensionPointRuntime_Builder_PerExtensionPoint.res), so iterate accordingly.
-  const publishToAggregates = {};
-  for (const [aggName, envVarName] of Object.entries(config.publishToAggregates || {})) {
-    const queueUrl = process.env[envVarName] || "";
-    publishToAggregates[aggName] = sqsPublishJsons(makeQueueRef(queueUrl), "SQS_FIFO");
-  }
-
-  const callbackConfig = {
-    publishToAggregates,
-    commandTopicResources: [],
-    scheduler: {
-      create: async () => { throw new Error("Scheduler not available in bundled ExtensionPoint handler"); },
-      delete: async () => { throw new Error("Scheduler not available in bundled ExtensionPoint handler"); },
-    },
-    queryEngine: {
-      scan: async () => { throw new Error("QueryEngine not available in bundled ExtensionPoint handler"); },
-      query: async () => { throw new Error("QueryEngine not available in bundled ExtensionPoint handler"); },
-    },
-    resourceNaming: { name: (n) => n, resolve: (n) => n },
-  };
-
-  const callback = extensionPointCallbackMake(callbackConfig)(patchedSpec)(mappingsModule);
+  const callback = extensionPointCallbackMake(Ops.makeCallbackSpec(config))(patchedSpec)(mappingsModule);
   const commandTopicCallback = commandTopicCallbackMake(patchedSpec)({
     Spec: patchedSpec,
     commandsHandler: callback.handleIncomingCommands,
   });
 
-  const resolvedQueue = makeQueueRef(config.queueUrl);
-  // Pair the handler with the extension point it serves so the invocation's log
-  // lines name the component, not just this Lambda.
-  return {
-    sqsHandler: handleQueueEvent(resolvedQueue, commandTopicCallback.handleJsonCommands),
-    comp: `ExtensionPoint(${patchedSpec.name})`,
-  };
+  return Ops.makeBuilt(config, patchedSpec.name, commandTopicCallback.handleJsonCommands);
 }
 
-const initPromise = buildHandler();
-
-export async function handler(event, context) {
-  setRequestId(context?.awsRequestId);
-  const { sqsHandler, comp } = await initPromise;
-  const records = event.Records || [];
-
-  log.debug("processing " + records.length.toString() + " record(s)", { comp: "ExtensionPointRuntime" });
-  await runEffect(sqsHandler(event, context), {
-    correlationId: extractMetaField(records, "correlationId"),
-    causationId: extractMetaField(records, "causationId"),
-    comp,
-    timestamp: extractSentTimestamp(records),
-    retryCount: extractRetryCount(records),
-  });
-  return "";
-}
+export const handler = Ops.makeHandler(build());

package/src/adapter/Runtime/ExtensionPointEntryPoint_Ops.res

@@ -0,0 +1,150 @@
+// Typed cold-start core for the (per-extension-point) ExtensionPoint Lambda
+// entry point.
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md):
+// ExtensionPointEntryPoint.mjs keeps only the untyped seam — the dynamic
+// `import()` of the spec/mappings modules named in HANDLER_CONFIG, the
+// `patchSpecId` fix-up, and the ExtensionPoint_Callback.Make /
+// CommandTopic_Callback.Make functor applications consuming them. The callback
+// config (publish dict, scheduler/query stubs, resource naming), HANDLER_CONFIG
+// parsing, and the SQS dispatch boundary live here, fully type-checked.
+//
+// The former shell's stub records carried wrong field names (`create`/`delete`
+// for Scheduler.operations' `createSchedule`/`deleteSchedule`, `name`/`resolve`
+// for ResourceNaming.operations' `validateName`/`urnName`) — a mapping touching
+// them crashed with "not a function" instead of the intended error. The typed
+// records fix the shapes; scheduler/queryEngine still throw by design (not
+// available in the bundled handler).
+
+@val @scope("process") external processEnv: dict<string> = "env"
+
+// ── Shim bindings (HandlerFactoryHelpers.mjs), typed for SQS records ────────
+@module("./HandlerFactoryHelpers.mjs")
+external setRequestId: string => unit = "setRequestId"
+@module("./HandlerFactoryHelpers.mjs")
+external runEffect: (
+  Effect.t<'a, 'e, 'r>,
+  StreamRoutedEntryPoint_Ops.dispatchOpts,
+) => promise<unit> = "runEffect"
+@module("./HandlerFactoryHelpers.mjs")
+external extractMetaField: (array<PulumiAws.SQS.Queue.record>, string) => option<string> =
+  "extractMetaField"
+@module("./HandlerFactoryHelpers.mjs")
+external extractSentTimestamp: array<PulumiAws.SQS.Queue.record> => option<float> =
+  "extractSentTimestamp"
+@module("./HandlerFactoryHelpers.mjs")
+external extractRetryCount: array<PulumiAws.SQS.Queue.record> => int = "extractRetryCount"
+@module("./HandlerFactoryHelpers.mjs") @scope("log")
+external logDebug: (string, StreamRoutedEntryPoint_Ops.dispatchOpts) => unit = "debug"
+
+// ── HANDLER_CONFIG ──────────────────────────────────────────────────────────
+// Written by ExtensionPointRuntime_Builder_PerExtensionPoint; all fields
+// optional so a partial config degrades like the former shell's `|| ""` reads.
+
+type handlerConfig = {
+  specModule?: string,
+  mappingsModule?: string,
+  queueUrl?: string,
+  // aggregateName → env-var name holding the aggregate's cmd-topic SQS URL.
+  publishToAggregates?: dict<string>,
+}
+@val @scope("JSON") external jsonParse: string => handlerConfig = "parse"
+// A real binding (not a bare external) so the shell can import it.
+let parseHandlerConfig = (raw: string): handlerConfig => jsonParse(raw)
+
+// ── Callback config (first argument of ExtensionPoint_Callback.Make) ────────
+// The record's field names/types mirror ExtensionPoint_Callback's `Spec` module
+// type — the compiled functor consumes it as a plain object.
+
+type callbackSpec = {
+  publishToAggregates: dict<ReventlessCore.CommandTopic.publishJsons>,
+  commandTopicResources: array<ReventlessInfra.Adapter.resolvedResource>,
+  scheduler: ReventlessCore.Scheduler.operations,
+  queryEngine: Reventless.QueryEngine.operations,
+  resourceNaming: ReventlessInfra.ResourceNaming.operations,
+}
+
+let makeCallbackSpec = (config: handlerConfig): callbackSpec => {
+  publishToAggregates: config.publishToAggregates
+  ->Option.getOr(Dict.make())
+  ->Dict.toArray
+  ->Array.map(((aggName, envVarName)) => {
+    let queueUrl = processEnv->Dict.get(envVarName)->Option.getOr("")
+    let queue: Util_SQS_Runtime.resolvedQueue = {id: queueUrl, name: queueUrl, arn: ""}
+    (aggName, queue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO))
+  })
+  ->Dict.fromArray,
+  commandTopicResources: [],
+  scheduler: {
+    createSchedule: (_, _) =>
+      JsError.throwWithMessage("Scheduler not available in bundled ExtensionPoint handler"),
+    deleteSchedule: (_, _) =>
+      JsError.throwWithMessage("Scheduler not available in bundled ExtensionPoint handler"),
+  },
+  queryEngine: {
+    scan: (~readModelName as _, ~filterConfigs as _, ~limit as _) =>
+      JsError.throwWithMessage("QueryEngine not available in bundled ExtensionPoint handler"),
+    query: (
+      ~readModelName as _,
+      ~key as _=?,
+      ~id as _,
+      ~subIdConfig as _=?,
+      ~filterConfigs as _=?,
+      ~ascending as _=?,
+      ~limit as _=?,
+    ) => JsError.throwWithMessage("QueryEngine not available in bundled ExtensionPoint handler"),
+  },
+  resourceNaming: {
+    validateName: n => n,
+    urnName: n => n,
+  },
+}
+
+// ── SQS dispatch boundary ───────────────────────────────────────────────────
+// The shell resolves the spec module, applies the functors, and hands the
+// typed jsonCommandsHandler back here; `comp` pairs the invocation's log lines
+// with the extension point the Lambda serves, not just the Lambda itself.
+
+type built = {
+  comp: string,
+  sqsHandler: (
+    PulumiAws.SQS.Queue.event,
+    PulumiAws.Lambda.context,
+  ) => Effect.t<unit, string, unit>,
+}
+
+let makeBuilt = (
+  config: handlerConfig,
+  specName: string,
+  handleJsonCommands: ReventlessCore.CommandTopic.jsonCommandsHandler,
+): built => {
+  let queueUrl = config.queueUrl->Option.getOr("")
+  let queue: Util_SQS_Runtime.resolvedQueue = {id: queueUrl, name: queueUrl, arn: ""}
+  {
+    comp: `ExtensionPoint(${specName})`,
+    sqsHandler: CommandTopicChannel_SQS_Runtime.handleQueueEvent(queue, handleJsonCommands),
+  }
+}
+
+let makeHandler = (buildPromise: promise<built>) =>
+  async (event: PulumiAws.SQS.Queue.event, context: PulumiAws.Lambda.context) => {
+    setRequestId(context.awsRequestId)
+    let {comp, sqsHandler} = await buildPromise
+    let records = event.records
+
+    logDebug(
+      `processing ${records->Array.length->Int.toString} record(s)`,
+      {comp: "ExtensionPointRuntime"},
+    )
+    await runEffect(
+      sqsHandler(event, context),
+      {
+        correlationId: ?extractMetaField(records, "correlationId"),
+        causationId: ?extractMetaField(records, "causationId"),
+        comp,
+        timestamp: ?extractSentTimestamp(records),
+        retryCount: extractRetryCount(records),
+      },
+    )
+    ""
+  }