@reventlessdev/reventless-core 3.0.0-alpha.176 → 3.0.0-alpha.178

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.178 (2026-07-22)
+
+### Bug Fixes
+
+* **core:** derive the disconnect schedule's rule name in one place ([6324a5b](https://github.com/ReventlessDev/reventless-core/commit/6324a5bc678a375688ec98571423f164b09375ae))
+
+
+# 3.0.0-alpha.177 (2026-07-22)
+
+* refactor!: retire the stale "Admin" vocabulary for platform-owned resources ([2770bd9](https://github.com/ReventlessDev/reventless-core/commit/2770bd96f309142bdfc65b9f36bd1a3ef60641bd))
+
+### BREAKING CHANGES
+
+* platform-owned resources are renamed Admin* -> Platform*
+(PlatformDcbEventLog, PlatformDcbCmdTopic, PlatformEventColl). This replaces
+a DynamoDB table, an SQS queue and an SNS topic — wipe and redeploy rather
+than migrate. Both alpha AdminDcbEventLog tables held 0 items at the time of
+the rename. MCP resource URI templates change from Admin/<field>/{id} to
+Platform/<field>/{id}; MCP tool names are unaffected.
+
+
+
 # 3.0.0-alpha.176 (2026-07-22)
 
 * refactor!: retire the stale "core" vocabulary for platform things ([34e7480](https://github.com/ReventlessDev/reventless-core/commit/34e7480992bd58906a250b0a1ce6ff2c5ba45260))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.176",
+  "version": "3.0.0-alpha.178",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -30,15 +30,15 @@
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.30",
     "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.13",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.13",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.14",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.104",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
+    "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.80",
-    "@reventlessdev/rescript-uuid": "1.1.0-alpha.17"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.104",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.80"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/admin/Platform_Admin.res

@@ -35,7 +35,7 @@ module Make = (
     with type runtimeParts = RuntimeEnvironment.parts,
   QueryEngineAdapter: QueryDb_Adapter.QueryEngineAdapter,
   ClonerRunner: Cloner.Adapter.Runner,
-  AdminRuntimeBuilder: PluginRuntime_Builder.T
+  PlatformRuntimeBuilder: PluginRuntime_Builder.T
     with module EventCollectorChannel = EventCollectorChannel
     and type runtimeParts = RuntimeEnvironment.parts,
   DcbEventLogStorage: DcbEventLog_Adapter.Storage,
@@ -51,9 +51,9 @@ module Make = (
     ECC: EventCollector_Adapter.Channel with type runtimeParts = RE.parts,
     RB: PluginRuntime_Builder.T with module EventCollectorChannel = ECC,
   ) => {
-    module AdminEventCollector = EventCollector_Builder.Make(RE, ECC)
+    module PlatformEventCollector = EventCollector_Builder.Make(RE, ECC)
     let make = (~name, ~eventTopics, ~opts) => {
-      let eventCollector = AdminEventCollector.make(~name, ~eventTopics, ~owner={kind: ComponentType.Plugin, name}, ~opts)
+      let eventCollector = PlatformEventCollector.make(~name, ~eventTopics, ~owner={kind: ComponentType.Plugin, name}, ~opts)
       let eventCollectorOutputs = eventCollector->Component.outputs
       (eventCollector, eventCollectorOutputs)
     }
@@ -76,8 +76,8 @@ module Make = (
 
       resources->Pulumi.Output.apply(resources => {
         let fakePluginDefinition: Reventless.Plugin.pluginDefinition = {
-          id: "Admin@INTERNAL",
-          name: "Admin",
+          id: Platform_Admin_Structure.pluginId ++ "@INTERNAL",
+          name: Platform_Admin_Structure.pluginId,
           version: "INTERNAL",
           extensionPoints: [],
           extensions: [],
@@ -90,11 +90,11 @@ module Make = (
           kind: Domain,
         }
 
-        module Callback = Admin_Callback.Make({
+        module Callback = Platform_Admin_Callback.Make({
           let pluginDefinition = fakePluginDefinition
           let outgoingExtensionPointJsonEventsHandlers = extensionPointsOutgoingJsonEventsHandlers
         })
-        let handler = AdminEventCollector.makeHandler(
+        let handler = PlatformEventCollector.makeHandler(
           ~eventCollector,
           ~jsonEventsHandler=Callback.handleJsonEvents,
         )
@@ -120,7 +120,9 @@ module Make = (
     ~outboundTranslationSlices: array<module(ReventlessInfra.OutboundTranslationSlice.T)>,
     ~inboundTranslationSlices: array<module(ReventlessInfra.InboundTranslationSlice.T)>,
   ) => {
-    let name = "Admin"
+    // Names every platform-owned resource — the DCB substrate via DcbBuilder and the
+    // EventCollector below. Bound to pluginId so the two can't drift apart again.
+    let name = Platform_Admin_Structure.pluginId
     let opts: Pulumi.ComponentResource.options = {}
 
     // Construct DCB components and derive DCB-specific API schema entries
@@ -129,7 +131,7 @@ module Make = (
       DcbEventTopicPublisher,
       DcbCommandTopicChannel,
       DcbCommandTopicChannelAsync,
-      AdminRuntimeBuilder,
+      PlatformRuntimeBuilder,
       Config,
     )
     // Aggregates constructed early so multi-source AutomationSlices created
@@ -142,15 +144,15 @@ module Make = (
     // `mutationResolverHook` and populate `aggregateMutationFieldsRegistry`.
     // The matching SDL entries are owned by
     // `PluginBaseFragment.pluginAggregateMutationEntries` (picked up via
-    // `AdminApi.mutationEntries`) so the AWS path that pushes
-    // `AdminApi.baseFragment` directly stays aligned with the in-memory path.
+    // `Platform_AdminApi.mutationEntries`) so the AWS path that pushes
+    // `Platform_AdminApi.baseFragment` directly stays aligned with the in-memory path.
     aggregates->Plugin_Helpers.registerAdminAggregateMutations(~hooks=Config.hooks)
 
     let dcbResult = DcbBuilder.construct(
       ~name,
       ~childName=name,
       // Admin slice command mutations render `Platform_*` (not `Admin_*`), byte-aligned with the
-      // hand-declared admin SDL (`AdminApi.baseFragment`, via `Api_Naming.adminField`) so the
+      // hand-declared admin SDL (`Platform_AdminApi.baseFragment`, via `Api_Naming.adminField`) so the
       // auto-bound DCB resolver targets the exact field name that is pushed to the schema.
       ~apiNamePrefix="Platform",
       // Admin DCB mutation resolvers bind to the Platform API (split mode), not the deploy-target
@@ -178,13 +180,13 @@ module Make = (
     | None => ()
     }
 
-    // Admin schema — composed from actual config. `AdminApi.mutationEntries`
+    // Admin schema — composed from actual config. `Platform_AdminApi.mutationEntries`
     // already includes the auto-derived `Platform_Plugin_Activate`/`Deactivate`
     // entries (via `PluginBaseFragment.pluginAggregateMutationEntries`) so the
     // SDL stays in sync with the resolver wiring fired above.
-    let adminMutationEntries = AdminApi.mutationEntries(~cloner=Config.cloner)
+    let adminMutationEntries = Platform_AdminApi.mutationEntries(~cloner=Config.cloner)
     let allMutationEntries = Array.concat(adminMutationEntries, dcbResult.mutationEntries)
-    let allQueryEntries = Array.concat(AdminApi.queryEntries, dcbResult.queryEntries)
+    let allQueryEntries = Array.concat(Platform_AdminApi.queryEntries, dcbResult.queryEntries)
     let adminFragment = GraphQL_FragmentGenerator.generate(
       ~mutationEntries=allMutationEntries,
       ~queryEntries=allQueryEntries,
@@ -202,7 +204,7 @@ module Make = (
       switch Config.hooks.mcpSchemaRegistrationHook {
       | Some(registerMcp) =>
         registerMcp({
-          pluginName: "Admin",
+          pluginName: name,
           mutationEntries: allMutationEntries,
           queryEntries: allQueryEntries,
           eventLogEntries: dcbResult.eventLogEntries,
@@ -227,7 +229,7 @@ module Make = (
     // match the `Platform_Plugin`/`Platform_Plugins` SDL fields declared by
     // PluginBaseFragment.queryEntries — leaving the SDL fields without a
     // resolver and producing "Cannot return null for non-nullable type" errors.
-    AdminApi.queryEntries->Array.forEach(entry => {
+    Platform_AdminApi.queryEntries->Array.forEach(entry => {
       let prefix = "Platform_"
       let entityName = if entry.returnTypeName->String.startsWith(prefix) {
         entry.returnTypeName->String.slice(
@@ -278,7 +280,7 @@ module Make = (
     //
     // BUT skip the StateViewSlice merge on a static-schema-push platform (AWS, where
     // preAdminResolversSchemaHook is Some): there the pushed schema is the static
-    // AdminApi.baseFragment, which does NOT declare the auto `<prefix>_<Slice>` query
+    // Platform_AdminApi.baseFragment, which does NOT declare the auto `<prefix>_<Slice>` query
     // fields — so creating their resolvers would fail CreateResolver with
     // "No field named Admin_<Slice> on type Query". The admin StateView slices are
     // internal registries whose real query surface is served by dedicated Lambda
@@ -401,7 +403,7 @@ module Make = (
         module EventCollectorHelper = MakeEventCollectorHelper(
           RuntimeEnvironment,
           EventCollectorChannel,
-          AdminRuntimeBuilder,
+          PlatformRuntimeBuilder,
         )
         let (eventCollector, _eventCollectorOutputs) = EventCollectorHelper.make(
           ~name,

package/src/admin/Platform_Admin.res.mjs

@@ -6,25 +6,26 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
 import * as Cloner$ReventlessCore from "../components/Cloner.res.mjs";
-import * as AdminApi$ReventlessCore from "./AdminApi.res.mjs";
 import * as Aggregate$ReventlessCore from "../components/Aggregate/Aggregate.res.mjs";
 import * as Component$ReventlessCore from "../components/Component.res.mjs";
 import * as ReadModel$ReventlessCore from "../components/ReadModel/ReadModel.res.mjs";
 import * as Dcb_Builder$ReventlessCore from "../components/Dcb/Dcb_Builder.res.mjs";
-import * as Admin_Callback$ReventlessCore from "./Admin_Callback.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "../plugin/component/Plugin_Helpers.res.mjs";
 import * as Builder_Helpers$ReventlessCore from "../components/Builder_Helpers.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "../components/Api/GraphQL_Stitcher.res.mjs";
 import * as Plugin_Structure$ReventlessCore from "../plugin/component/Plugin_Structure.res.mjs";
+import * as Platform_AdminApi$ReventlessCore from "./Platform_AdminApi.res.mjs";
 import * as EventCollector_Builder$ReventlessCore from "../components/EventCollector/EventCollector_Builder.res.mjs";
+import * as Platform_Admin_Callback$ReventlessCore from "./Platform_Admin_Callback.res.mjs";
+import * as Platform_Admin_Structure$ReventlessCore from "./Platform_Admin_Structure.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "../components/Api/GraphQL_FragmentGenerator.res.mjs";
 
 function Make(RuntimeEnvironment) {
-  return EventCollectorChannel => (QueryEngineAdapter => (ClonerRunner => (AdminRuntimeBuilder => (DcbEventLogStorage => (DcbEventTopicPublisher => (DcbCommandTopicChannel => (DcbCommandTopicChannelAsync => (Config => {
+  return EventCollectorChannel => (QueryEngineAdapter => (ClonerRunner => (PlatformRuntimeBuilder => (DcbEventLogStorage => (DcbEventTopicPublisher => (DcbCommandTopicChannel => (DcbCommandTopicChannelAsync => (Config => {
     let MakeEventCollectorHelper = RE => (ECC => (RB => {
-      let AdminEventCollector = EventCollector_Builder$ReventlessCore.Make(RE)(ECC);
+      let PlatformEventCollector = EventCollector_Builder$ReventlessCore.Make(RE)(ECC);
       let make = (name, eventTopics, opts) => {
-        let eventCollector = AdminEventCollector.make(name, eventTopics, {
+        let eventCollector = PlatformEventCollector.make(name, eventTopics, {
           kind: "Plugin",
           name: name
         }, opts);
@@ -38,8 +39,8 @@ function Make(RuntimeEnvironment) {
         let resources = Pulumi.all(extensionPointsOutputs.map(extensionPoint => extensionPoint.eventTopic)).apply(eventTopics => eventTopics.map(eventTopic => eventTopic.resources).flat());
         return resources.apply(resources => {
           let fakePluginDefinition = {
-            id: "Admin@INTERNAL",
-            name: "Admin",
+            id: Platform_Admin_Structure$ReventlessCore.pluginId + "@INTERNAL",
+            name: Platform_Admin_Structure$ReventlessCore.pluginId,
             version: "INTERNAL",
             extensionPoints: [],
             extensions: [],
@@ -51,39 +52,38 @@ function Make(RuntimeEnvironment) {
             dcbEventLog: undefined,
             kind: "Domain"
           };
-          let Callback = Admin_Callback$ReventlessCore.Make({
+          let Callback = Platform_Admin_Callback$ReventlessCore.Make({
             pluginDefinition: fakePluginDefinition,
             outgoingExtensionPointJsonEventsHandlers: extensionPointsOutgoingJsonEventsHandlers
           });
-          let handler = AdminEventCollector.makeHandler(eventCollector, Callback.handleJsonEvents);
+          let handler = PlatformEventCollector.makeHandler(eventCollector, Callback.handleJsonEvents);
           RB.forPluginEventCollector(handler, eventTopics, resources, undefined, undefined, eventCollector);
         });
       };
       return {
-        AdminEventCollector: AdminEventCollector,
+        PlatformEventCollector: PlatformEventCollector,
         make: make,
         connect: connect
       };
     }));
     let construct = (param, extensionPoints, aggregates, readModels, scheduler, resourceNaming, api, apiRole, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices) => {
-      let name = "Admin";
       let opts = {};
-      let DcbBuilder = Dcb_Builder$ReventlessCore.Make(DcbEventLogStorage)(DcbEventTopicPublisher)(DcbCommandTopicChannel)(DcbCommandTopicChannelAsync)(AdminRuntimeBuilder)({
+      let DcbBuilder = Dcb_Builder$ReventlessCore.Make(DcbEventLogStorage)(DcbEventTopicPublisher)(DcbCommandTopicChannel)(DcbCommandTopicChannelAsync)(PlatformRuntimeBuilder)({
         hooks: Config.hooks
       });
       let aggregatesWithoutEventMappers = Builder_Helpers$ReventlessCore.createAggregatesWithoutEventMappers(aggregates, api, {}, opts);
       let aggregateEventTopics = Aggregate$ReventlessCore.allEventTopics(aggregatesWithoutEventMappers);
       Plugin_Helpers$ReventlessCore.registerAdminAggregateMutations(aggregates, Config.hooks);
-      let dcbResult = DcbBuilder.construct(name, name, "Platform", true, undefined, undefined, aggregateEventTopics, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, undefined, undefined, undefined, opts);
+      let dcbResult = DcbBuilder.construct(Platform_Admin_Structure$ReventlessCore.pluginId, Platform_Admin_Structure$ReventlessCore.pluginId, "Platform", true, undefined, undefined, aggregateEventTopics, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, undefined, undefined, undefined, opts);
       let slicePublishJsons = dcbResult.dcbPublishJsons;
       if (slicePublishJsons !== undefined) {
         stateChangeSlices.forEach(Sc => {
           Builder_Helpers$ReventlessCore.publishToAggregates[Sc.Spec.name] = slicePublishJsons;
         });
       }
-      let adminMutationEntries = AdminApi$ReventlessCore.mutationEntries(Config.cloner);
+      let adminMutationEntries = Platform_AdminApi$ReventlessCore.mutationEntries(Config.cloner);
       let allMutationEntries = adminMutationEntries.concat(dcbResult.mutationEntries);
-      let allQueryEntries = AdminApi$ReventlessCore.queryEntries.concat(dcbResult.queryEntries);
+      let allQueryEntries = Platform_AdminApi$ReventlessCore.queryEntries.concat(dcbResult.queryEntries);
       let adminFragment = GraphQL_FragmentGenerator$ReventlessCore.generate(allMutationEntries, allQueryEntries);
       if (dcbResult.mutationEntries.length !== 0 || dcbResult.queryEntries.length !== 0) {
         let registerTypes = Config.hooks.schemaTypeRegistrationHook;
@@ -94,7 +94,7 @@ function Make(RuntimeEnvironment) {
         let registerMcp = Config.hooks.mcpSchemaRegistrationHook;
         if (registerMcp !== undefined) {
           registerMcp({
-            pluginName: "Admin",
+            pluginName: Platform_Admin_Structure$ReventlessCore.pluginId,
             mutationEntries: allMutationEntries,
             queryEntries: allQueryEntries,
             eventLogEntries: dcbResult.eventLogEntries,
@@ -104,9 +104,9 @@ function Make(RuntimeEnvironment) {
       }
       let dcbOutputs = dcbResult.dcbEventLogOutputs;
       if (dcbOutputs !== undefined) {
-        aggregateEventTopics[name + "DcbEventLog"] = dcbOutputs.eventTopic;
+        aggregateEventTopics[Platform_Admin_Structure$ReventlessCore.pluginId + "DcbEventLog"] = dcbOutputs.eventTopic;
       }
-      AdminApi$ReventlessCore.queryEntries.forEach(entry => {
+      Platform_AdminApi$ReventlessCore.queryEntries.forEach(entry => {
         let prefix = "Platform_";
         let entityName = entry.returnTypeName.startsWith(prefix) ? entry.returnTypeName.slice(prefix.length, entry.returnTypeName.length) : entry.returnTypeName;
         let registryKey = Stdlib_Option.getOr(entry.specName, entityName);
@@ -175,9 +175,9 @@ function Make(RuntimeEnvironment) {
         let aggregateNames = Stdlib_Array.reduce(extensionPointsOutputs.map(extensionPointOutputs => Belt_SetString.fromArray(extensionPointOutputs.aggregateNames)), undefined, Belt_SetString.union);
         let aggregatesOutputs = Builder_Helpers$ReventlessCore.addEventMappers(aggregateEventTopics, queryEngine);
         let eventTopics = Aggregate$ReventlessCore.filterEventTopics(aggregatesOutputs, aggregateNames);
-        let AdminEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
+        let PlatformEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
         let make = (name, eventTopics, opts) => {
-          let eventCollector = AdminEventCollector.make(name, eventTopics, {
+          let eventCollector = PlatformEventCollector.make(name, eventTopics, {
             kind: "Plugin",
             name: name
           }, opts);
@@ -191,8 +191,8 @@ function Make(RuntimeEnvironment) {
           let resources = Pulumi.all(extensionPointsOutputs.map(extensionPoint => extensionPoint.eventTopic)).apply(eventTopics => eventTopics.map(eventTopic => eventTopic.resources).flat());
           return resources.apply(resources => {
             let fakePluginDefinition = {
-              id: "Admin@INTERNAL",
-              name: "Admin",
+              id: Platform_Admin_Structure$ReventlessCore.pluginId + "@INTERNAL",
+              name: Platform_Admin_Structure$ReventlessCore.pluginId,
               version: "INTERNAL",
               extensionPoints: [],
               extensions: [],
@@ -204,15 +204,15 @@ function Make(RuntimeEnvironment) {
               dcbEventLog: undefined,
               kind: "Domain"
             };
-            let Callback = Admin_Callback$ReventlessCore.Make({
+            let Callback = Platform_Admin_Callback$ReventlessCore.Make({
               pluginDefinition: fakePluginDefinition,
               outgoingExtensionPointJsonEventsHandlers: extensionPointsOutgoingJsonEventsHandlers
             });
-            let handler = AdminEventCollector.makeHandler(eventCollector, Callback.handleJsonEvents);
-            AdminRuntimeBuilder.forPluginEventCollector(handler, eventTopics, resources, undefined, undefined, eventCollector);
+            let handler = PlatformEventCollector.makeHandler(eventCollector, Callback.handleJsonEvents);
+            PlatformRuntimeBuilder.forPluginEventCollector(handler, eventTopics, resources, undefined, undefined, eventCollector);
           });
         };
-        let match$1 = make(name, eventTopics, opts);
+        let match$1 = make(Platform_Admin_Structure$ReventlessCore.pluginId, eventTopics, opts);
         let eventCollector = match$1[0];
         Output$Pulumi.flatMap(Pulumi.all(match[1]), extensionPointsOutgoingJsonEventsHandlers => connect(eventCollector, eventTopics, extensionPointsOutputs, extensionPointsOutgoingJsonEventsHandlers));
         Stdlib_Option.forEach(dcbResult.dcbRuntimeSetup, dcbRuntimeSetup => dcbRuntimeSetup());

package/src/admin/{Admin_Callback.res → Platform_Admin_Callback.res}

@@ -12,7 +12,7 @@ module Make = (Spec: Spec): T => {
     stream
     ->Stream.mapEffect(eventJson' =>
       EffectLogger.logInfo(
-        ~comp="Admin",
+        ~comp=Platform_Admin_Structure.pluginId,
         `handleJsonEvents: outgoing event: ${LogFormat.event'JsonToLogMessage(eventJson')}`,
       )->Effect.zipRight(
         Effect.all(

package/src/admin/{Admin_Callback.res.mjs → Platform_Admin_Callback.res.mjs}

@@ -4,9 +4,10 @@ import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as LogFormat$ReventlessCore from "../util/LogFormat.res.mjs";
 import * as EffectLogger$ReventlessCore from "../util/EffectLogger.res.mjs";
+import * as Platform_Admin_Structure$ReventlessCore from "./Platform_Admin_Structure.res.mjs";
 
 function Make(Spec) {
-  let handleJsonEvents = stream => Stream.runDrain(Stream.mapEffect(stream, eventJson$p => Effect.zipRight(EffectLogger$ReventlessCore.logInfo("Admin", undefined, `handleJsonEvents: outgoing event: ` + LogFormat$ReventlessCore.event$pJsonToLogMessage(eventJson$p)), Effect.map(Effect.all(Spec.outgoingExtensionPointJsonEventsHandlers.map(handleEvent => Effect.promise(() => handleEvent(eventJson$p, Spec.pluginDefinition))), {
+  let handleJsonEvents = stream => Stream.runDrain(Stream.mapEffect(stream, eventJson$p => Effect.zipRight(EffectLogger$ReventlessCore.logInfo(Platform_Admin_Structure$ReventlessCore.pluginId, undefined, `handleJsonEvents: outgoing event: ` + LogFormat$ReventlessCore.event$pJsonToLogMessage(eventJson$p)), Effect.map(Effect.all(Spec.outgoingExtensionPointJsonEventsHandlers.map(handleEvent => Effect.promise(() => handleEvent(eventJson$p, Spec.pluginDefinition))), {
     concurrency: "unbounded"
   }), param => {}))));
   return {

package/src/plugin/component/Plugin_Helpers.res

@@ -88,7 +88,7 @@ let getStorageResources = (allQueryDbs, pluginName, queryDbName) =>
 // ---------------------------------------------------------------------------
 // Plugin EventCollector context registry.
 //
-// Adapter runtime entry points (e.g. AdminEventCollectorEntryPoint.mjs) read
+// Adapter runtime entry points (e.g. EventCollectorEntryPoint.mjs) read
 // HANDLER_CONFIG to reconstruct Plugin_Callback at cold start. The JSON payload
 // is assembled at deploy time inside `forPluginEventCollector` (AWS), but the
 // plugin-specific data (pluginDefinition, the auto-included Connect extension
@@ -1024,7 +1024,7 @@ module NoopHooksConfig: HooksConfig = {
 // and fire `mutationResolverHook` so adapter-side SDL stubs get registered
 // synchronously. The matching `mutationSchemaEntry` records — needed to keep the
 // SDL aligned — live in `PluginBaseFragment.pluginAggregateMutationEntries` so the
-// AWS path (which pushes `AdminApi.baseFragment` directly, not Admin.construct's
+// AWS path (which pushes `Platform_AdminApi.baseFragment` directly, not Admin.construct's
 // adminFragment) picks them up too. This helper is side-effect only.
 let registerAdminAggregateMutations = (
   type a,

package/src/plugin/connect/PluginConnectExtension_Mapping.res

@@ -78,7 +78,7 @@ module Make = (Spec: Spec) => {
         // plugins used to call DoConnectPlugin / DoDisconnectPlugin here so
         // each plugin's EC Lambda could subscribe / unsubscribe its own
         // queue to peer EP topics. Admin owns that work now
-        // (manageSubscriptions in AdminEventCollectorEntryPoint.mjs) — these
+        // (manageSubscriptions in EventCollectorEntryPoint.mjs) — these
         // cases drop to no-ops.
         | _ => []
         }

package/src/plugin/connect/PluginExtensionPoint_Plugin.res

@@ -29,6 +29,13 @@ module type Spec = {
 }
 
 module Make = (Spec: Spec) => {
+  // Single owner of the disconnect schedule's rule name. Create and delete must
+  // derive it identically — they previously did not (create prefixed the stack,
+  // delete did not), so every delete targeted a name that was never created and
+  // the rule survived. The stack prefix itself is load-bearing: several stacks
+  // share one EventBridge bus, and an unprefixed plugin id would collide.
+  let disconnectScheduleName = id => Spec.environment ++ ("-" ++ id)
+
   let forwardCommand = async (
     _id,
     command,
@@ -104,7 +111,7 @@ module Make = (Spec: Spec) => {
     switch directive {
     | PluginExtensionPointSpec.CreateDisconnectSchedule(id, timeout) =>
       await createSchedule({
-        name: Spec.environment ++ ("-" ++ id),
+        name: id->disconnectScheduleName,
         rate: timeout->ScheduleOps.minutesFromNow,
         payload: {
           Message.id,
@@ -114,7 +121,7 @@ module Make = (Spec: Spec) => {
         ->Message.encodeCommand'(S.string, PluginExtensionPointSpec.commandSchema)
         ->JSON.stringify,
       })
-    | DeleteDisconnectSchedule(id) => await deleteSchedule(id)
+    | DeleteDisconnectSchedule(id) => await deleteSchedule(id->disconnectScheduleName)
     | ForwardCommand({id, command, extensionPointName}) =>
       await forwardCommand(id, command, extensionPointName, queryEngine)
     | DoConnectPlugin(pluginDef) =>

package/src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs

@@ -23,6 +23,7 @@ function disconnectGrace(interval) {
 }
 
 function Make(Spec) {
+  let disconnectScheduleName = id => Spec.environment + ("-" + id);
   let forwardCommand = async (_id, command, extensionPointName, queryEngine) => {
     let jsons = await queryEngine.scan(PluginSpec$ReventlessCore.name, [
       [
@@ -81,7 +82,7 @@ function Make(Spec) {
       case "CreateDisconnectSchedule" :
         let id = directive._0;
         return await createSchedule({
-          name: Spec.environment + ("-" + id),
+          name: disconnectScheduleName(id),
           rate: ScheduleOps$ReventlessCore.minutesFromNow(directive._1),
           payload: JSON.stringify(Message$ReventlessCore.encodeCommand$p({
             id: id,
@@ -90,7 +91,7 @@ function Make(Spec) {
           }, S.string, PluginExtensionPointSpec$ReventlessInfra.commandSchema))
         });
       case "DeleteDisconnectSchedule" :
-        return await deleteSchedule(directive._0);
+        return await deleteSchedule(disconnectScheduleName(directive._0));
       case "DoConnectPlugin" :
         let fn = Spec.manageSubscriptions;
         if (fn !== undefined) {
@@ -355,6 +356,7 @@ function Make(Spec) {
     mapOutgoingEvent: mapOutgoingEvent
   });
   return {
+    disconnectScheduleName: disconnectScheduleName,
     forwardCommand: forwardCommand,
     directiveHandler: directiveHandler,
     PluginMapping: PluginMapping,

package/tests/api/GraphQL_StitcherTest.res

@@ -53,7 +53,7 @@ describe("GraphQL_Stitcher.subscriptionSources", () => {
   })
 
   testSync("core-emitted admin base fragment carries no provider directives", () => {
-    let base = AdminApi.baseFragment(~cloner=true)
+    let base = Platform_AdminApi.baseFragment(~cloner=true)
     expect(base.encoded->String.includes("@aws_subscribe"))->toBe(false)
     expect(base.encoded->String.includes("@aws_auth"))->toBe(false)
     // The subscription→mutation fan-in rides the structured metadata instead.

package/tests/extensionpoint/PluginDisconnectScheduleTest.res

@@ -0,0 +1,66 @@
+// Guards the disconnect schedule's rule name. Create and delete must derive it
+// identically: they previously did not — create prefixed `Spec.environment`,
+// delete did not — so every delete targeted a rule that had never been created
+// and the real rule survived. The leak is invisible at runtime, because the
+// delete reports success against a name AWS simply doesn't have.
+
+open JestGlobals
+
+let created: ref<array<string>> = ref([])
+let deleted: ref<array<string>> = ref([])
+
+module DisconnectSpec = {
+  let runtimeOps: PluginRuntimeOperations.operations = {
+    messagePublish: {
+      sendMessageToChannel: async (~channelId as _, ~messageBody as _) => (),
+    },
+  }
+  let environment = "teststack"
+  let updateApiSchema = None
+  let manageSubscriptions = None
+}
+
+module EP = PluginExtensionPoint_Plugin.Make(DisconnectSpec)
+
+let createSchedule: Reventless.Schedule.create = async schedule => {
+  created := created.contents->Array.concat([schedule.name])
+}
+
+let deleteSchedule: Reventless.Schedule.delete = async name => {
+  deleted := deleted.contents->Array.concat([name])
+}
+
+let queryEngine: Reventless.QueryEngine.operations = {
+  scan: async (~readModelName as _, ~filterConfigs as _, ~limit as _) => [],
+  query: async (
+    ~readModelName as _,
+    ~key as _=?,
+    ~id as _,
+    ~subIdConfig as _=?,
+    ~filterConfigs as _=?,
+    ~ascending as _=?,
+    ~limit as _=?,
+  ) => [],
+}
+
+let pluginId = "Catalog_1.0.0-alpha.169"
+
+let handle = directive => EP.directiveHandler(createSchedule, deleteSchedule, queryEngine, directive)
+
+describe("plugin disconnect schedule", () => {
+  test("create and delete address the same rule name", async () => {
+    created := []
+    deleted := []
+    await handle(ReventlessInfra.PluginExtensionPointSpec.CreateDisconnectSchedule(pluginId, 5))
+    await handle(DeleteDisconnectSchedule(pluginId))
+    expect(deleted.contents)->toEqual(created.contents)
+  })
+
+  test("the rule name is namespaced by stack", async () => {
+    created := []
+    await handle(ReventlessInfra.PluginExtensionPointSpec.CreateDisconnectSchedule(pluginId, 5))
+    // Several stacks share one EventBridge bus, so a bare plugin id would
+    // collide across them.
+    expect(created.contents)->toEqual(["teststack-" ++ pluginId])
+  })
+})