@reventlessdev/reventless-core 3.0.0-alpha.214 → 3.0.0-alpha.216

package/src/components/CommandTopic/CommandTopic_Helpers.res.mjs

@@ -1,11 +1,42 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+
+let commandOutcomeHook = {
+  contents: undefined
+};
+
+function registerCommandOutcome(hook) {
+  commandOutcomeHook.contents = hook;
+}
+
+function clearCommandOutcome() {
+  commandOutcomeHook.contents = undefined;
+}
+
+function fireCommandOutcome(component, reference, outcome) {
+  Stdlib_Option.forEach(commandOutcomeHook.contents, hook => {
+    try {
+      hook({
+        component: component,
+        reference: reference,
+        outcome: outcome
+      });
+      return;
+    } catch (raw_err) {
+      let err = Primitive_exceptions.internalToException(raw_err);
+      return Effect.runSync(EffectLogger$ReventlessCore.logError(`CommandTopic(` + component + `)`, undefined, `command-outcome hook threw (ignored): ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err), Stdlib_JsExn.message), "unknown")));
+    }
+  });
+}
 
 let acceptedResultChannel = {
   contents: undefined
@@ -15,12 +46,23 @@ let rejectedResultChannel = {
   contents: undefined
 };
 
-function reportAccepted(reference, result) {
+function reportAccepted(component, reference, result) {
   Stdlib_Option.forEach(acceptedResultChannel.contents, cb => cb(reference, result));
+  fireCommandOutcome(component, reference, {
+    TAG: "OutcomeAccepted",
+    entityId: result.entityId,
+    eventCount: result.eventCount
+  });
 }
 
-function reportRejected(reference, result) {
+function reportRejected(component, cause, reference, result) {
   Stdlib_Option.forEach(rejectedResultChannel.contents, cb => cb(reference, result));
+  fireCommandOutcome(component, reference, {
+    TAG: "OutcomeRejected",
+    errorCode: result.errorCode,
+    errorDetail: result.errorDetail,
+    cause: cause
+  });
 }
 
 function commandOutcomeToJson(outcome) {
@@ -179,6 +221,10 @@ function getHandlers(typeName) {
 }
 
 export {
+  commandOutcomeHook,
+  registerCommandOutcome,
+  clearCommandOutcome,
+  fireCommandOutcome,
   acceptedResultChannel,
   rejectedResultChannel,
   reportAccepted,

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -322,6 +322,7 @@ module Make = (
             // No append, but the read snapshot is valid — cache it for the next command.
             cachePut((state, headPosition))
             CommandTopic_Helpers.reportAccepted(
+              ~component=Spec.name,
               cmdJson.meta.msgId,
               switch entityId {
               | Some(eid) => {entityId: eid, eventCount: 0}
@@ -373,6 +374,7 @@ module Make = (
                   // next command's delta read picks our events up from `headPosition`.
                   cachePut((state, headPosition))
                   CommandTopic_Helpers.reportAccepted(
+                    ~component=Spec.name,
                     cmdJson.meta.msgId,
                     switch entityId {
                     | Some(eid) => {entityId: eid, eventCount: rawEvents->Array.length}
@@ -412,7 +414,12 @@ module Make = (
                     if errorCode == "Conflict" {
                       Metrics.emitCount(~metric="AppendConflict", ~slice=Spec.name)
                     }
+                    // Both arms here are storage, not the model: a surfaced Conflict is
+                    // contention the retry loop couldn't absorb, and AppendFailed is the
+                    // store failing. `decide` had already said Ok.
                     CommandTopic_Helpers.reportRejected(
+                      ~component=Spec.name,
+                      ~cause=InfrastructureFailure,
                       cmdJson.meta.msgId,
                       {errorCode, errorDetail: errDetail},
                     )
@@ -433,7 +440,12 @@ module Make = (
               payloadDict->Dict.toArray->Array.length == 0
                 ? ""
                 : payloadDict->JSON.Encode.object->JSON.stringify
-            CommandTopic_Helpers.reportRejected(cmdJson.meta.msgId, {errorCode, errorDetail})
+            CommandTopic_Helpers.reportRejected(
+              ~component=Spec.name,
+              ~cause=DomainRejection,
+              cmdJson.meta.msgId,
+              {errorCode, errorDetail},
+            )
             EffectLogger.logError(
               ~comp,
               `decide rejected: ${errorCode} ${errorDetail}`,

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs

@@ -173,7 +173,7 @@ function Make(Spec) {
                   state,
                   headPosition
                 ]);
-                CommandTopic_Helpers$ReventlessCore.reportAccepted(cmdJson.meta.msgId, entityId !== undefined ? ({
+                CommandTopic_Helpers$ReventlessCore.reportAccepted(Spec.name, cmdJson.meta.msgId, entityId !== undefined ? ({
                     entityId: entityId,
                     eventCount: 0
                   }) : ({
@@ -223,7 +223,7 @@ function Make(Spec) {
                     state,
                     headPosition
                   ]);
-                  CommandTopic_Helpers$ReventlessCore.reportAccepted(cmdJson.meta.msgId, entityId !== undefined ? ({
+                  CommandTopic_Helpers$ReventlessCore.reportAccepted(Spec.name, cmdJson.meta.msgId, entityId !== undefined ? ({
                       entityId: entityId,
                       eventCount: rawEvents.length
                     }) : ({
@@ -257,7 +257,7 @@ function Make(Spec) {
                   if (errorCode === "Conflict") {
                     Metrics$ReventlessCore.emitCount("AppendConflict", Spec.name, undefined);
                   }
-                  CommandTopic_Helpers$ReventlessCore.reportRejected(cmdJson.meta.msgId, {
+                  CommandTopic_Helpers$ReventlessCore.reportRejected(Spec.name, "InfrastructureFailure", cmdJson.meta.msgId, {
                     errorCode: errorCode,
                     errorDetail: errDetail
                   });
@@ -277,7 +277,7 @@ function Make(Spec) {
             let match = Message$ReventlessCore.splitMessage(errorJson);
             let payloadDict = match[1];
             let errorDetail = Object.entries(payloadDict).length === 0 ? "" : JSON.stringify(payloadDict);
-            CommandTopic_Helpers$ReventlessCore.reportRejected(cmdJson.meta.msgId, {
+            CommandTopic_Helpers$ReventlessCore.reportRejected(Spec.name, "DomainRejection", cmdJson.meta.msgId, {
               errorCode: errorCode,
               errorDetail: errorDetail
             });

package/src/plugin/component/Plugin_Builder.res

@@ -529,6 +529,7 @@ module Make = (
           {
             commandTypes: extractTypes(Scs.Spec.commandSchema),
             eventTypes: extractEventTypes(Scs.Spec.eventSchema->S.castToUnknown),
+            errorTypes: extractTypes(Scs.Spec.errorSchema),
             consumedEventTypes: extractEventTypes(Scs.Spec.consumedEventSchema->S.castToUnknown),
             chapter: ?chapterFor(Scs.Spec.name),
           },

package/src/plugin/component/Plugin_Builder.res.mjs

@@ -373,6 +373,7 @@ function Make(Spec) {
           stateSchemas[Scs.Spec.name] = {
             commandTypes: DcbTag$Reventless.extractAllVariantNames(Scs.Spec.commandSchema),
             eventTypes: DcbTag$Reventless.extractVariantNames(Scs.Spec.eventSchema),
+            errorTypes: DcbTag$Reventless.extractAllVariantNames(Scs.Spec.errorSchema),
             consumedEventTypes: DcbTag$Reventless.extractVariantNames(Scs.Spec.consumedEventSchema),
             chapter: chapterByName[Scs.Spec.name]
           };

package/src/plugin/component/Plugin_Structure.res

@@ -157,6 +157,70 @@ let labelFieldsFromStateSchema = (
     }
   }
 
+// ── Per-variant event / error field extraction (Phase 6.3) ───────────────────
+// Mirrors toCommandDef/extractCommandDefs for emitted events: name (TAG const),
+// payload JSON Schema, and cross-entity references. Module-level rather than
+// inside `make` because the synthetic Platform_Admin structure — hand-written,
+// because its components never pass through `make` — has to derive its defs the
+// same way, and a second copy of this walk would be free to drift from this one.
+
+let toEventDef = (v: S.t<unknown>): option<Reventless.Plugin.eventDef> => {
+  let mkDef = (~variantName, ~properties) => {
+    let references =
+      properties
+      ->Dict.toArray
+      ->Array.filterMap(((fieldName, fieldSchema)) =>
+        Reventless.Reference.getTarget(fieldSchema)->Option.map(target => (
+          {
+            Reventless.Plugin.fieldName,
+            entity: target.entity,
+            plugin: target.plugin,
+          }: Reventless.Plugin.fieldReference
+        ))
+      )
+    ({
+      Reventless.Plugin.name: variantName,
+      // Derived for the same reason as `commandDef.schema`: an event's field
+      // markers are the write side's half of the same vocabulary.
+      schema: v->SuryToJsonSchema.deriveObjectSchema->JSON.stringify,
+      references,
+    }: Reventless.Plugin.eventDef)
+  }
+  switch v {
+  | Object({properties}) =>
+    properties
+    ->Dict.get("TAG")
+    ->Option.flatMap(tagSchema =>
+      switch tagSchema {
+      | String({const: ?Some(variantName)}) => Some(mkDef(~variantName, ~properties))
+      | _ => None
+      }
+    )
+  // Payload-less event variants (`| Archived`) compile to a bare string literal.
+  // DCB-projection lookups can't WHERE-clause on them, so they stay out of
+  // producedEventTypes/consumedEventTypes; but the full `events` list carries them
+  // so the event graph can still draw the emitted (orphan) event node.
+  | String({const: ?Some(variantName)}) => Some(mkDef(~variantName, ~properties=Dict.make()))
+  | _ => None
+  }
+}
+
+let extractEventDefs = (eventSchema: S.t<unknown>): array<Reventless.Plugin.eventDef> =>
+  switch eventSchema {
+  | Union({anyOf}) => anyOf->Array.filterMap(toEventDef)
+  | _ => toEventDef(eventSchema)->Option.mapOr([], def => [def])
+  }
+
+// Declared errors walk identically to emitted events — an error variant is a
+// variant, and the payload-less form (`| CategoryNotFound`) is the common case
+// the bare-string branch above already handles. Reusing the walk rather than
+// copying it keeps the two from drifting; only the def type differs, so that a
+// consumer (and the SDL) can tell a refusal from a fact.
+let extractErrorDefs = (errorSchema: S.t<unknown>): array<Reventless.Plugin.errorDef> =>
+  extractEventDefs(errorSchema)->Array.map(({name, schema, references}) => (
+    {name, schema, references}: Reventless.Plugin.errorDef
+  ))
+
 let make = (
   type api role,
   ~name: string,
@@ -330,57 +394,6 @@ let make = (
       ->Option.mapOr([], def => [def])
     }
 
-  // ── Per-variant event field extraction (Phase 6.3) ─────────────────────────
-  // Mirrors toCommandDef/extractCommandDefs for emitted events: name (TAG const),
-  // payload JSON Schema, and cross-entity references.
-
-  let toEventDef = (v: S.t<unknown>): option<Reventless.Plugin.eventDef> => {
-    let mkDef = (~variantName, ~properties) => {
-      let references =
-        properties
-        ->Dict.toArray
-        ->Array.filterMap(((fieldName, fieldSchema)) =>
-          Reventless.Reference.getTarget(fieldSchema)->Option.map(target => (
-            {
-              Reventless.Plugin.fieldName,
-              entity: target.entity,
-              plugin: target.plugin,
-            }: Reventless.Plugin.fieldReference
-          ))
-        )
-      ({
-        Reventless.Plugin.name: variantName,
-        // Derived for the same reason as `commandDef.schema` above: an event's
-        // field markers are the write side's half of the same vocabulary.
-        schema: v->SuryToJsonSchema.deriveObjectSchema->JSON.stringify,
-        references,
-      }: Reventless.Plugin.eventDef)
-    }
-    switch v {
-    | Object({properties}) =>
-      properties
-      ->Dict.get("TAG")
-      ->Option.flatMap(tagSchema =>
-        switch tagSchema {
-        | String({const: ?Some(variantName)}) => Some(mkDef(~variantName, ~properties))
-        | _ => None
-        }
-      )
-    // Payload-less event variants (`| Archived`) compile to a bare string literal.
-    // DCB-projection lookups can't WHERE-clause on them, so they stay out of
-    // producedEventTypes/consumedEventTypes; but the full `events` list carries them
-    // so the event graph can still draw the emitted (orphan) event node.
-    | String({const: ?Some(variantName)}) => Some(mkDef(~variantName, ~properties=Dict.make()))
-    | _ => None
-    }
-  }
-
-  let extractEventDefs = (eventSchema: S.t<unknown>): array<Reventless.Plugin.eventDef> =>
-    switch eventSchema {
-    | Union({anyOf}) => anyOf->Array.filterMap(toEventDef)
-    | _ => toEventDef(eventSchema)->Option.mapOr([], def => [def])
-    }
-
   // ── Per-component event type extraction ────────────────────────────────────
 
   let scsProduced =
@@ -704,6 +717,7 @@ let make = (
         linkedViews: linkedSvsFor(produced),
         consistencyRead: consistencyReadFor(consumed),
         events: extractEventDefs(SCS.Spec.eventSchema->S.castToUnknown),
+        errors: extractErrorDefs(SCS.Spec.errorSchema->S.castToUnknown),
         chapter: chapterOf(SCS.Spec.name),
       }: Reventless.Plugin.writableDef)
     })
@@ -726,6 +740,7 @@ let make = (
         linkedViews: Array.concat(linkedSvsFor(produced), linkedReadModelsFor(A.Spec.name)),
         consistencyRead: None,
         events: extractEventDefs(A.Spec.eventSchema->S.castToUnknown),
+        errors: extractErrorDefs(A.Spec.errorSchema->S.castToUnknown),
         chapter: chapterOf(A.Spec.name),
       }: Reventless.Plugin.writableDef)
     })

package/src/plugin/component/Plugin_Structure.res.mjs

@@ -140,6 +140,62 @@ function labelFieldsFromStateSchema(entityName, stateSchema) {
   };
 }
 
+function toEventDef(v) {
+  let mkDef = (variantName, properties) => {
+    let references = Stdlib_Array.filterMap(Object.entries(properties), param => {
+      let fieldName = param[0];
+      return Stdlib_Option.map(Reference$Reventless.getTarget(param[1]), target => ({
+        fieldName: fieldName,
+        entity: target.entity,
+        plugin: target.plugin
+      }));
+    });
+    return {
+      name: variantName,
+      schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(v)),
+      references: references
+    };
+  };
+  switch (v.type) {
+    case "string" :
+      let variantName = v.const;
+      if (variantName !== undefined) {
+        return mkDef(variantName, {});
+      } else {
+        return;
+      }
+    case "object" :
+      let properties = v.properties;
+      return Stdlib_Option.flatMap(properties["TAG"], tagSchema => {
+        if (tagSchema.type !== "string") {
+          return;
+        }
+        let variantName = tagSchema.const;
+        if (variantName !== undefined) {
+          return mkDef(variantName, properties);
+        }
+      });
+    default:
+      return;
+  }
+}
+
+function extractEventDefs(eventSchema) {
+  if (eventSchema.type === "union") {
+    return Stdlib_Array.filterMap(eventSchema.anyOf, toEventDef);
+  } else {
+    return Stdlib_Option.mapOr(toEventDef(eventSchema), [], def => [def]);
+  }
+}
+
+function extractErrorDefs(errorSchema) {
+  return extractEventDefs(errorSchema).map(param => ({
+    name: param.name,
+    schema: param.schema,
+    references: param.references
+  }));
+}
+
 function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionsOpt, extensionPointsOpt, componentChaptersOpt) {
   let aggregates = aggregatesOpt !== undefined ? aggregatesOpt : [];
   let readModels = readModelsOpt !== undefined ? readModelsOpt : [];
@@ -268,52 +324,6 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       return Stdlib_Option.mapOr(toCommandDef(isAggregate, mutationFieldFor, commandSchema, commandSchema), [], def => [def]);
     }
   };
-  let toEventDef = v => {
-    let mkDef = (variantName, properties) => {
-      let references = Stdlib_Array.filterMap(Object.entries(properties), param => {
-        let fieldName = param[0];
-        return Stdlib_Option.map(Reference$Reventless.getTarget(param[1]), target => ({
-          fieldName: fieldName,
-          entity: target.entity,
-          plugin: target.plugin
-        }));
-      });
-      return {
-        name: variantName,
-        schema: JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(v)),
-        references: references
-      };
-    };
-    switch (v.type) {
-      case "string" :
-        let variantName = v.const;
-        if (variantName !== undefined) {
-          return mkDef(variantName, {});
-        } else {
-          return;
-        }
-      case "object" :
-        let properties = v.properties;
-        return Stdlib_Option.flatMap(properties["TAG"], tagSchema => {
-          if (tagSchema.type !== "string") {
-            return;
-          }
-          let variantName = tagSchema.const;
-          if (variantName !== undefined) {
-            return mkDef(variantName, properties);
-          }
-        });
-      default:
-        return;
-    }
-  };
-  let extractEventDefs = eventSchema => {
-    if (eventSchema.type === "union") {
-      return Stdlib_Array.filterMap(eventSchema.anyOf, toEventDef);
-    } else {
-      return Stdlib_Option.mapOr(toEventDef(eventSchema), [], def => [def]);
-    }
-  };
   let scsProduced = stateChangeSlices.map(SCS => [
     SCS.Spec.name,
     qualify(name, DcbTag$Reventless.extractVariantNames(SCS.Spec.eventSchema))
@@ -541,6 +551,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       linkedViews: linkedSvsFor(produced),
       consistencyRead: consistencyReadFor(consumed),
       events: extractEventDefs(SCS.Spec.eventSchema),
+      errors: extractErrorDefs(SCS.Spec.errorSchema),
       chapter: componentChapters[SCS.Spec.name]
     };
   });
@@ -555,6 +566,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       linkedViews: linkedSvsFor(produced).concat(linkedReadModelsFor(A.Spec.name)),
       consistencyRead: undefined,
       events: extractEventDefs(A.Spec.eventSchema),
+      errors: extractErrorDefs(A.Spec.errorSchema),
       chapter: componentChapters[A.Spec.name]
     };
   });
@@ -641,6 +653,9 @@ export {
   statusFieldFromStateSchema,
   labelFieldSourceToString,
   labelFieldsFromStateSchema,
+  toEventDef,
+  extractEventDefs,
+  extractErrorDefs,
   make,
 }
 /* log Not a pure module */

package/tests/adapter/RuntimeExtensionHookReachTest.res

@@ -0,0 +1,84 @@
+open JestGlobals
+
+S.enableJson()
+
+// The point of the seam, end to end at the hook level: an extension that only
+// ever gets `onColdStart` can reach the framework's runtime callback hooks from
+// there, and they take effect on the requests that follow.
+//
+// `CommandGenerator_Callback.registerCommandInterceptor` stands in for all four
+// registrars — they share the shape (a module-level ref consulted on the hot
+// path), so what makes one reachable makes the others reachable too. What is
+// being proved is the ordering: registration happens inside the cold-start hook,
+// the command runs after it, and the interceptor is consulted.
+
+@schema
+type command = Add({@partitionTag productId: string, name: string})
+
+let published: ref<array<Message.commandJson>> = ref([])
+let publishJsons: CommandGenerator.publishJsons = async cmds =>
+  published := published.contents->Array.concat(cmds)
+
+let generateCommand = CommandGenerator_Callback.makeGenerateCommand(
+  ~publishJsons,
+  ~serviceName="Product",
+  ~commandSchema=commandSchema->S.castToUnknown,
+  ~componentKind=CommandGenerator_Callback.StateChangeSlice,
+  ~stripIdFromParams=false,
+)
+
+let addChair = (): CommandGenerator.payload =>
+  Obj.magic({
+    "command": "Add",
+    "arguments": {"productId": "p1", "name": "Chair"},
+    "meta": {"ip": ["127.0.0.1"], "user": "test-user", "info": ""},
+  })
+
+let runAdd = async () => await generateCommand(addChair())->Effect.runPromise
+
+describe("RuntimeExtension reaches the runtime callback hooks", () => {
+  beforeEach(() => {
+    RuntimeExtension.reset()
+    CommandGenerator_Callback.clearCommandInterceptor()
+    published := []
+  })
+
+  testPromise("an interceptor registered at cold start denies a later command", async () => {
+    let seenAtColdStart: array<string> = []
+    module Gatekeeper: RuntimeExtension.Extension = {
+      let moduleUrl = "file:///pkg/gatekeeper.res.mjs"
+      let onColdStart = (~runtimeKind as _, ~component, ~plugin as _, ~platform as _) => {
+        seenAtColdStart->Array.push(component)
+        CommandGenerator_Callback.registerCommandInterceptor(async (
+          ~identity as _,
+          ~componentName,
+          ~componentKind as _,
+          ~tag,
+          ~args as _,
+        ) => CommandGenerator_Callback.Deny(`${componentName}.${tag} refused`))
+      }
+    }
+    RuntimeExtension.use(module(Gatekeeper: RuntimeExtension.Extension))
+
+    RuntimeExtension.notifyColdStart(
+      ~runtimeKind=ComponentType.StateChangeSlice,
+      ~component="CatalogStateChanges",
+      ~plugin=Some("Catalog"),
+      ~platform=Some("Shop"),
+    )
+    expect(seenAtColdStart)->toEqual(["CatalogStateChanges"])
+
+    let denied = switch await runAdd() {
+    | _ => None
+    | exception exn => exn->JsExn.fromException->Option.flatMap(JsExn.message)
+    }
+
+    expect(denied)->toEqual(Some("Product.Add refused"))
+    expect(published.contents->Array.length)->toBe(0)
+  })
+
+  testPromise("with nothing registered the same command publishes untouched", async () => {
+    let _ = await runAdd()
+    expect(published.contents->Array.length)->toBe(1)
+  })
+})

package/tests/adapter/RuntimeExtensionHookReachTest.res.mjs

@@ -0,0 +1,95 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as RuntimeExtension$ReventlessCore from "../../src/adapter/RuntimeExtension/RuntimeExtension.res.mjs";
+import * as CommandGenerator_Callback$ReventlessCore from "../../src/components/CommandGenerator/CommandGenerator_Callback.res.mjs";
+
+S.enableJson();
+
+let commandSchema = S.schema(s => ({
+  TAG: "Add",
+  productId: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+let published = {
+  contents: []
+};
+
+async function publishJsons(cmds) {
+  published.contents = published.contents.concat(cmds);
+}
+
+let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(publishJsons, undefined, "Product", commandSchema, "StateChangeSlice", false);
+
+function addChair() {
+  return {
+    command: "Add",
+    arguments: {
+      productId: "p1",
+      name: "Chair"
+    },
+    meta: {
+      ip: ["127.0.0.1"],
+      user: "test-user",
+      info: ""
+    }
+  };
+}
+
+async function runAdd() {
+  return await Effect.runPromise(generateCommand(addChair()));
+}
+
+globalThis.describe("RuntimeExtension reaches the runtime callback hooks", () => {
+  globalThis.beforeEach(() => {
+    RuntimeExtension$ReventlessCore.reset();
+    CommandGenerator_Callback$ReventlessCore.clearCommandInterceptor();
+    published.contents = [];
+  });
+  globalThis.test("an interceptor registered at cold start denies a later command", async () => {
+    let seenAtColdStart = [];
+    let onColdStart = (param, component, param$1, param$2) => {
+      seenAtColdStart.push(component);
+      CommandGenerator_Callback$ReventlessCore.registerCommandInterceptor(async (param, componentName, param$1, tag, param$2) => ({
+        TAG: "Deny",
+        _0: componentName + `.` + tag + ` refused`
+      }));
+    };
+    let Gatekeeper = {
+      moduleUrl: "file:///pkg/gatekeeper.res.mjs",
+      onColdStart: onColdStart
+    };
+    RuntimeExtension$ReventlessCore.use(Gatekeeper);
+    RuntimeExtension$ReventlessCore.notifyColdStart("StateChangeSlice", "CatalogStateChanges", "Catalog", "Shop");
+    globalThis.expect(seenAtColdStart).toEqual(["CatalogStateChanges"]);
+    let denied;
+    try {
+      await runAdd();
+      denied = undefined;
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      denied = Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message);
+    }
+    globalThis.expect(denied).toEqual("Product.Add refused");
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+  globalThis.test("with nothing registered the same command publishes untouched", async () => {
+    await runAdd();
+    globalThis.expect(published.contents.length).toBe(1);
+  });
+});
+
+export {
+  commandSchema,
+  published,
+  publishJsons,
+  generateCommand,
+  addChair,
+  runAdd,
+}
+/*  Not a pure module */