@reventlessdev/reventless-infra 3.0.0-alpha.100

package/src/types/Platform.res

@@ -0,0 +1,269 @@
+// Platform module type — abstract factory interface for platform-agnostic component assembly.
+//
+// Lives in reventless-infra so application plugin assembly code can depend on
+// reventless-infra. The concrete implementation in reventless-aws satisfies this type.
+//
+// Usage pattern:
+//
+//   // app/MyPlugin.res — imports reventless-infra
+//   module Make = (Platform: ReventlessInfra.Platform.T) => {
+//     module MyAggregate = Platform.Aggregate.Make(MySpec, MyBehavior, MyMappings)
+//     module MyReadModel = Platform.ReadModel.Make(MyRmSpec, MyMappings)
+//     // ...
+//   }
+//
+//   // index.res — Composition Root; the only file that imports reventless-aws
+//   module Platform = ReventlessAws.Platform.Make(Config)
+//   module App = MyPlugin.Make(Platform)
+
+// Type alias for admin extension points dict — defined at file scope so it
+// remains accessible inside module type T even though T re-declares
+// `module ExtensionPoint` with a different local type, which would otherwise
+// shadow the package-level ExtensionPoint.outputs.
+/**
+Abstract factory interface for creating Reventless components without coupling
+application code to a specific infrastructure provider.
+
+Inject a `Platform.T` module (e.g. `ReventlessAws.Platform.Make(Config)`) at
+the composition root, and use its nested `Make` functors everywhere else.
+
+@example
+```rescript
+// CatalogPlugin.res — depends on reventless-infra
+module Make = (Platform: Platform.T) => {
+  module CategoryAggregate = Platform.Aggregate.Make(
+    Category,
+    CategoryBehavior,
+    NoEventMappings.Make(Category),
+  )
+  module CategoryReadModel = Platform.ReadModel.Make(CategoriesReadModel, CategoryMappings)
+}
+
+// index.res — the only file that imports reventless-aws
+module Platform = ReventlessAws.Platform.Make(AwsConfig)
+module App = CatalogPlugin.Make(Platform)
+```
+*/
+
+// Type alias so `deployPlugin` can reference `Plugin.outputs` inside module type T,
+// where `module Plugin: Plugin.T` shadows the package-level Plugin module.
+type pluginOutputs = Plugin.outputs
+
+// Module type alias so StateViewSliceStream can reference the component T
+// without being confused by the `module StateViewSlice` declaration inside T.
+module type StateViewSliceComponentT = StateViewSlice.T
+
+// Same trick for ReadModelStream: the nested `module ReadModel` declaration
+// inside T shadows the package-level ReadModel for later declarations, so
+// reference its component T through this file-scope alias.
+module type ReadModelComponentT = ReadModel.T
+
+module type T = {
+  /** Platform-specific API type (e.g. `Types.AppSync.api` for AWS, `unit` for in-memory). */
+  type api
+
+  /** Platform-specific role type (e.g. `Types.AppSync.role` for AWS, `unit` for in-memory). */
+  type role
+
+  /** The platform's API instance — used by bundled DCB slice builders that need
+      to create QueryDb resolvers inside the Platform functor. */
+  let api: api
+
+  /** The platform's API role instance — used alongside `api` for QueryDb resolvers. */
+  let apiRole: role
+
+  /** Factory for event-sourced aggregate components. */
+  module Aggregate: {
+    module Make: (
+      Spec: Reventless.Aggregate.Spec,
+      Behavior: Reventless.Behavior.T with module Spec := Spec,
+      EventMappings: EventMapper.Mappings with module Target := Spec,
+    ) => Aggregate.T with type api = api
+    /** Async variant — uses FIFO channel, returns `CommandPending`. */
+    module MakeAsync: (
+      Spec: Reventless.Aggregate.Spec,
+      Behavior: Reventless.Behavior.T with module Spec := Spec,
+      EventMappings: EventMapper.Mappings with module Target := Spec,
+    ) => Aggregate.T with type api = api
+  }
+
+  /** Factory for read model (query-side projection) components. */
+  module ReadModel: {
+    module Make: (
+      Spec: Reventless.ReadModel.Spec,
+      Mappings: Reventless.Projection.Mappings with module Target := Spec,
+    ) => ReadModel.T with module Spec = Spec and type api = api and type role = role
+  }
+
+  /** Factory for stream-enabled read model components — identical to `ReadModel`
+      but the QueryDb table has a DynamoDB Stream so the platform wires a
+      `StateTopic` Lambda that pushes row changes to the AppSync Events API
+      (Source B subscriptions / AutoUI live updates). In-memory: same as
+      `ReadModel` (no streams). */
+  module ReadModelStream: {
+    module Make: (
+      Spec: Reventless.ReadModel.Spec,
+      Mappings: Reventless.Projection.Mappings with module Target := Spec,
+    ) => ReadModelComponentT with module Spec = Spec and type api = api and type role = role
+  }
+
+  /** Factory for extension point components (single mapping). */
+  module ExtensionPoint: {
+    module Make: (
+      Mapping: ExtensionPointMapping.Mapping,
+    ) => ExtensionPoint.T
+
+    /** Two-mapping variant — merges per-slice EP mappings. */
+    module Make2: (
+      Mapping1: ExtensionPointMapping.Mapping,
+      Mapping2: ExtensionPointMapping.Mapping
+        with module ExtensionPoint = Mapping1.ExtensionPoint,
+    ) => ExtensionPoint.T
+
+    /** Three-mapping variant — merges per-slice EP mappings. */
+    module Make3: (
+      Mapping1: ExtensionPointMapping.Mapping,
+      Mapping2: ExtensionPointMapping.Mapping
+        with module ExtensionPoint = Mapping1.ExtensionPoint,
+      Mapping3: ExtensionPointMapping.Mapping
+        with module ExtensionPoint = Mapping1.ExtensionPoint,
+    ) => ExtensionPoint.T
+
+    /** Multi-mapping variant with full control over name and mappings array. */
+    module MakeMulti: (
+      Spec: ExtensionPointMapping.Spec,
+      Mappings: ExtensionPoint.Mappings with module Spec := Spec,
+    ) => ExtensionPoint.T
+  }
+
+  /** Factory for extension blueprints (single mapping).
+      Returns a blueprint — not a built component. `Plugin.make` builds it,
+      using the plugin name for the extension's component name and auto-merging
+      blueprints that target the same extension point. */
+  module Extension: {
+    module Make: (
+      Mapping: ExtensionMapping.Mapping,
+    ) => Extension.Blueprint
+  }
+
+  /** Factory for task (background job / S3 trigger) components. */
+  module Task: {
+    module Make: (Spec: Task.Spec) => Task.T with module Spec = Spec
+  }
+
+  /** Ready-to-use counter component (no Make required). */
+  module Counter: Counter.T
+
+  /** Factory for DCB write-side state-change slice components. */
+  module StateChangeSlice: {
+    module Make: (
+      Spec: Reventless.StateChangeSlice.Spec,
+      Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec,
+    ) => StateChangeSlice.T with module Spec = Spec
+    /** Async variant — uses FIFO channel, returns `CommandPending`. */
+    module MakeAsync: (
+      Spec: Reventless.StateChangeSlice.Spec,
+      Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec,
+    ) => StateChangeSlice.T with module Spec = Spec
+  }
+
+  /** Factory for DCB read-side state-view slice components. */
+  module StateViewSlice: {
+    module Make: (
+      Spec: Reventless.StateViewSlice.Spec,
+      Projection: Reventless.StateViewSlice.Projection with module Spec := Spec,
+    ) => StateViewSlice.T with module Spec = Spec
+  }
+
+  /** Factory for stream-enabled state-view slice components (enables Source B subscriptions). */
+  module StateViewSliceStream: {
+    module Make: (
+      Spec: Reventless.StateViewSlice.Spec,
+      Projection: Reventless.StateViewSlice.Projection with module Spec := Spec,
+    ) => StateViewSliceComponentT with module Spec = Spec
+  }
+
+  /** Factory for DCB automation slice components (TODO list pattern). */
+  module AutomationSlice: {
+    module Make: (
+      Spec: Reventless.AutomationSlice.Spec,
+      Automation: Reventless.AutomationSlice.Automation with module Spec := Spec,
+    ) => AutomationSlice.T with module Spec = Spec
+  }
+
+  /** Factory for DCB outbound translation slice components (tracked external calls). */
+  module OutboundTranslationSlice: {
+    module Make: (
+      Spec: Reventless.OutboundTranslationSlice.Spec,
+      Translation: Reventless.OutboundTranslationSlice.Translation with module Spec := Spec,
+    ) => OutboundTranslationSlice.T with module Spec = Spec
+  }
+
+  /** Factory for DCB inbound translation slice components (external input to commands). */
+  module InboundTranslationSlice: {
+    module Make: (
+      Spec: Reventless.InboundTranslationSlice.Spec,
+      Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec,
+    ) => InboundTranslationSlice.T with module Spec = Spec
+  }
+
+  /** Whether this platform supports MCP (Model Context Protocol) for AI agent access.
+      In-memory: starts an MCP server alongside GraphQL in makePlatform.
+      AWS: deploys a Lambda Function URL with Streamable HTTP transport. */
+  type mcpSupported = | @as(true) McpSupported | @as(false) McpNotSupported
+  let mcpSupported: mcpSupported
+
+  /** Which AppSync API a plugin's resolvers and schema are deployed to.
+      Domain — the application-facing API (default, backwards-compatible).
+      Platform — the admin/Platform_Sync* API (for framework-internal plugins). */
+  type apiTarget = Domain | Platform
+
+  /** Factory for plugin deployment units. */
+  module Plugin: Plugin.T with type api = api and type role = role
+
+  /** Module type for plugin assembly — matches the `make` function produced by
+      every plugin's `Make` functor. Pass first-class modules to `makePlatform`. */
+  module type PluginMaker = {
+    let make: unit => Plugin.component
+  }
+
+  /** Optional host UI shell bundle. When set, the platform hosts the static
+      shell (e.g. reventless-ui's host-shell `dist/`) on its own CDN and writes
+      a `config.json` next to `index.html` so the shell discovers the API
+      endpoint at boot. In-memory platforms typically ignore this — the shell
+      is served by `vite dev` against the running in-process GraphQL server. */
+  type hostUiBundleConfig = {
+    assetsDir: string,
+    bundleVersion: string,
+  }
+
+  /** Deploy a complete platform: creates the scheduler, builds each plugin,
+      creates admin components internally, and wires everything (schema stitching + stack exports). */
+  let makePlatform: (
+    ~version: string,
+    ~plugins: array<module(PluginMaker)>,
+  ) => unit
+
+  /** Deploy only the platform (admin components, scheduler, shared API).
+      No plugins are deployed — each plugin deploys independently via `deployPlugin`.
+      Pass `~hostUiBundle` to also host a static host-shell SPA from this stack.
+      Returns the Pulumi stack outputs dict for use as the ESM `default` export. */
+  let deployPlatform: (
+    ~version: string,
+    ~hostUiBundle: hostUiBundleConfig=?,
+  ) => dict<Pulumi.Output.t<JSON.t>>
+
+  /** Deploy a single plugin as an independent stack.
+      Creates its own scheduler and exports stack outputs for cross-stack consumption.
+      Pass `~apiTarget=Platform` to route the plugin's resolvers and schema to the Platform API.
+      Defaults to `Domain`.
+      Returns the Pulumi stack outputs dict for use as the ESM `default` export. */
+  let deployPlugin: (~plugin: module(PluginMaker), ~apiTarget: apiTarget=?) => dict<Pulumi.Output.t<JSON.t>>
+
+  /** Start all servers after all makePlatform/deployPlugin calls are complete.
+      In split in-memory mode, servers are deferred until this is called so all
+      plugins (domain and platform) can register their schema before serving requests.
+      In AWS and unified in-memory mode this is a no-op — server lifecycle is managed
+      by Pulumi / existing inline start() calls. */
+  let startServers: unit => unit
+}

package/src/types/Platform.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/types/PluginExtensionPointSpec.res

@@ -0,0 +1,55 @@
+let name = "Core.Plugin"
+
+include Reventless.Plugin
+
+@schema
+type timeout = int // in minutes
+
+@schema
+type forwardCommand = {
+  extensionPointName: string,
+  id: string,
+  command: string,
+}
+
+@schema
+type command =
+  | Heartbeat(timeout)
+  | ConnectPlugin(pluginDefinition)
+  | DisconnectPlugin
+  | ForwardCommand(forwardCommand)
+  // Registers this plugin's UI-fragment manifest with the admin UiFragmentRegistry slice.
+  // Sent by the plugin's connect extension alongside ConnectPlugin (see
+  // docs/plans/event-sourced-fragment-registries.md). Routed by the admin EP's UI-fragment
+  // mapping to UiFragmentRegistry.RegisterUiFragment; DisconnectPlugin drives the matching
+  // DeregisterUiFragment. Decoupling the manifest from the Plugin aggregate's lifecycle.
+  | RegisterUiFragment(uiFragmentManifest)
+  // Deploy-time re-detect: fired once by `deployPlugin` on every (re)deploy. Unlike
+  // a keep-alive `Heartbeat`, this forces the connect handshake to run again for an
+  // already-connected version so its current definition (e.g. a newly added `kind`,
+  // updated uiFragments/protocols) is re-serialized onto the lifecycle row. Carries
+  // the timeout so it also re-arms the disconnect schedule like a heartbeat.
+  | RedetectPlugin(timeout)
+
+@schema
+type event =
+  | UnknownPluginDetected
+  // Emitted when a connecting plugin declared incompatible protocol versions.
+  // The plugin is still connected; this event gives operators visibility.
+  | IncompatiblePlugin(pluginDefinition)
+  | PluginConnected(pluginDefinition)
+  | PluginReconnected(pluginDefinition)
+  | PluginDisconnected(pluginDefinition)
+  | PluginDeactivated(pluginDefinition)
+  | PluginActivated(pluginDefinition)
+  | PluginRetired(pluginDefinition)
+
+@schema
+type directive =
+  | CreateDisconnectSchedule(string, timeout)
+  | DeleteDisconnectSchedule(string)
+  | DoConnectPlugin(pluginDefinition)
+  | DoDisconnectPlugin(pluginDefinition)
+  | ForwardCommand(forwardCommand)
+
+let moduleUrl: string = %raw(`import.meta.url`)

package/src/types/PluginExtensionPointSpec.res.mjs

@@ -0,0 +1,209 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+
+let forwardCommandSchema = S.schema(s => ({
+  extensionPointName: s.m(S.string),
+  id: s.m(S.string),
+  command: s.m(S.string)
+}));
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "Heartbeat",
+    _0: s.m(S.int)
+  })),
+  S.schema(s => ({
+    TAG: "ConnectPlugin",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.literal("DisconnectPlugin"),
+  S.schema(s => ({
+    TAG: "ForwardCommand",
+    _0: s.m(forwardCommandSchema)
+  })),
+  S.schema(s => ({
+    TAG: "RegisterUiFragment",
+    _0: s.m(Plugin$Reventless.uiFragmentManifestSchema)
+  })),
+  S.schema(s => ({
+    TAG: "RedetectPlugin",
+    _0: s.m(S.int)
+  }))
+]);
+
+let eventSchema = S.union([
+  S.literal("UnknownPluginDetected"),
+  S.schema(s => ({
+    TAG: "IncompatiblePlugin",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "PluginConnected",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "PluginReconnected",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "PluginDisconnected",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "PluginDeactivated",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "PluginActivated",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "PluginRetired",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  }))
+]);
+
+let directiveSchema = S.union([
+  S.schema(s => ({
+    TAG: "CreateDisconnectSchedule",
+    _0: s.m(S.string),
+    _1: s.m(S.int)
+  })),
+  S.schema(s => ({
+    TAG: "DeleteDisconnectSchedule",
+    _0: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "DoConnectPlugin",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "DoDisconnectPlugin",
+    _0: s.m(Plugin$Reventless.pluginDefinitionSchema)
+  })),
+  S.schema(s => ({
+    TAG: "ForwardCommand",
+    _0: s.m(forwardCommandSchema)
+  }))
+]);
+
+let moduleUrl = import.meta.url;
+
+let name = "Core.Plugin";
+
+let nameSchema = Plugin$Reventless.nameSchema;
+
+let versionSchema = Plugin$Reventless.versionSchema;
+
+let pluginKindSchema = Plugin$Reventless.pluginKindSchema;
+
+let extensionPointDefinitionSchema = Plugin$Reventless.extensionPointDefinitionSchema;
+
+let extensionDefinitionSchema = Plugin$Reventless.extensionDefinitionSchema;
+
+let dcbEventLogDefinitionSchema = Plugin$Reventless.dcbEventLogDefinitionSchema;
+
+let extensionProtocolSchema = Plugin$Reventless.extensionProtocolSchema;
+
+let apiSchemaFragmentSchema = Plugin$Reventless.apiSchemaFragmentSchema;
+
+let apiTargetSchema = Plugin$Reventless.apiTargetSchema;
+
+let apiSchemaFragmentOptionSchema = Plugin$Reventless.apiSchemaFragmentOptionSchema;
+
+let dcbEventLogOptionSchema = Plugin$Reventless.dcbEventLogOptionSchema;
+
+let stringOptionSchema = Plugin$Reventless.stringOptionSchema;
+
+let stringArrayOptionSchema = Plugin$Reventless.stringArrayOptionSchema;
+
+let boolOptionSchema = Plugin$Reventless.boolOptionSchema;
+
+let panelManifestEntrySchema = Plugin$Reventless.panelManifestEntrySchema;
+
+let menuEntrySchema = Plugin$Reventless.menuEntrySchema;
+
+let pageManifestEntrySchema = Plugin$Reventless.pageManifestEntrySchema;
+
+let uiFragmentManifestSchema = Plugin$Reventless.uiFragmentManifestSchema;
+
+let uiFragmentManifestOptionSchema = Plugin$Reventless.uiFragmentManifestOptionSchema;
+
+let commandLevelSchema = Plugin$Reventless.commandLevelSchema;
+
+let fieldReferenceSchema = Plugin$Reventless.fieldReferenceSchema;
+
+let commandDefSchema = Plugin$Reventless.commandDefSchema;
+
+let queryableDefSchema = Plugin$Reventless.queryableDefSchema;
+
+let eventDefSchema = Plugin$Reventless.eventDefSchema;
+
+let writableDefSchema = Plugin$Reventless.writableDefSchema;
+
+let automationSliceDefSchema = Plugin$Reventless.automationSliceDefSchema;
+
+let outboundTranslationSliceDefSchema = Plugin$Reventless.outboundTranslationSliceDefSchema;
+
+let inboundTranslationSliceDefSchema = Plugin$Reventless.inboundTranslationSliceDefSchema;
+
+let extensionDefSchema = Plugin$Reventless.extensionDefSchema;
+
+let extensionPointDefSchema = Plugin$Reventless.extensionPointDefSchema;
+
+let extensionPointDefArrayOptionSchema = Plugin$Reventless.extensionPointDefArrayOptionSchema;
+
+let pluginStructureSchema = Plugin$Reventless.pluginStructureSchema;
+
+let pluginStructureOptionSchema = Plugin$Reventless.pluginStructureOptionSchema;
+
+let pluginDefinitionSchema = Plugin$Reventless.pluginDefinitionSchema;
+
+let timeoutSchema = S.int;
+
+export {
+  name,
+  nameSchema,
+  versionSchema,
+  pluginKindSchema,
+  extensionPointDefinitionSchema,
+  extensionDefinitionSchema,
+  dcbEventLogDefinitionSchema,
+  extensionProtocolSchema,
+  apiSchemaFragmentSchema,
+  apiTargetSchema,
+  apiSchemaFragmentOptionSchema,
+  dcbEventLogOptionSchema,
+  stringOptionSchema,
+  stringArrayOptionSchema,
+  boolOptionSchema,
+  panelManifestEntrySchema,
+  menuEntrySchema,
+  pageManifestEntrySchema,
+  uiFragmentManifestSchema,
+  uiFragmentManifestOptionSchema,
+  commandLevelSchema,
+  fieldReferenceSchema,
+  commandDefSchema,
+  queryableDefSchema,
+  eventDefSchema,
+  writableDefSchema,
+  automationSliceDefSchema,
+  outboundTranslationSliceDefSchema,
+  inboundTranslationSliceDefSchema,
+  extensionDefSchema,
+  extensionPointDefSchema,
+  extensionPointDefArrayOptionSchema,
+  pluginStructureSchema,
+  pluginStructureOptionSchema,
+  pluginDefinitionSchema,
+  timeoutSchema,
+  forwardCommandSchema,
+  commandSchema,
+  eventSchema,
+  directiveSchema,
+  moduleUrl,
+}
+/* forwardCommandSchema Not a pure module */

package/src/types/ResourceNaming.res

@@ -0,0 +1,12 @@
+/**
+Provider-agnostic interface for naming infrastructure resources.
+
+Injected into extension points and tasks so they can derive unique,
+valid resource names without coupling to a specific cloud provider.
+*/
+type operations = {
+  /** Validates and sanitizes a proposed resource name to comply with provider rules. */
+  validateName: string => string,
+  /** Derives a URN-safe name for use in Pulumi resource URNs. */
+  urnName: string => string,
+}

package/src/types/ResourceNaming.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/tests/DeployBootstrapTest.res

@@ -0,0 +1,72 @@
+open JestGlobals
+
+module DB = DeployBootstrap
+
+describe("DeployBootstrap", () => {
+  // The seam holds module-level state, so each case resets first for isolation.
+  describe("run with no registrations", () => {
+    testSync("is a no-op that does not throw", () => {
+      DB.reset()
+      DB.run(PreDeploy)
+      DB.run(PostDeploy)
+      expect(true)->toBe(true)
+    })
+  })
+
+  describe("registration order within a phase", () => {
+    testSync("runs contributions in the order they were registered", () => {
+      DB.reset()
+      let calls = []
+      DB.register(() => calls->Array.push("a"))
+      DB.register(() => calls->Array.push("b"))
+      DB.register(() => calls->Array.push("c"))
+      DB.run(PreDeploy)
+      expect(calls)->toEqual(["a", "b", "c"])
+    })
+  })
+
+  describe("phase isolation", () => {
+    testSync("run(PreDeploy) fires only PreDeploy contributions", () => {
+      DB.reset()
+      let calls = []
+      DB.register(~phase=PreDeploy, () => calls->Array.push("pre"))
+      DB.register(~phase=PostDeploy, () => calls->Array.push("post"))
+      DB.run(PreDeploy)
+      expect(calls)->toEqual(["pre"])
+      DB.run(PostDeploy)
+      expect(calls)->toEqual(["pre", "post"])
+    })
+
+    testSync("defaults to PreDeploy when no phase is given", () => {
+      DB.reset()
+      let calls = []
+      DB.register(() => calls->Array.push("default"))
+      DB.run(PostDeploy)
+      expect(calls)->toEqual([])
+      DB.run(PreDeploy)
+      expect(calls)->toEqual(["default"])
+    })
+  })
+
+  describe("idempotent run per phase", () => {
+    testSync("running an already-run phase does nothing", () => {
+      DB.reset()
+      let count = ref(0)
+      DB.register(() => count := count.contents + 1)
+      DB.run(PreDeploy)
+      DB.run(PreDeploy)
+      DB.run(PreDeploy)
+      expect(count.contents)->toBe(1)
+    })
+
+    testSync("a contribution registered after run does not fire", () => {
+      DB.reset()
+      let calls = []
+      DB.register(() => calls->Array.push("before"))
+      DB.run(PreDeploy)
+      DB.register(() => calls->Array.push("after"))
+      DB.run(PreDeploy)
+      expect(calls)->toEqual(["before"])
+    })
+  })
+})