@reventlessdev/reventless-infra 3.0.0-alpha.81

package/src/components/EventTopic.res

@@ -0,0 +1,51 @@
+/**
+Module type for an aggregate's event topic specification.
+
+`EventTopic.T` is used by the framework to identify the event channel
+(e.g. an SNS topic) and validate that published events match the
+aggregate's event schema.
+*/
+module type T = {
+  module Id: Reventless.Id.T
+
+  /** Logical name of the aggregate or component owning this event topic. */
+  let name: string
+
+  /** The event type published to this topic. Must carry `@schema` for serialization. */
+  @schema
+  type event
+}
+
+/**
+Deploy-time outputs produced when an `EventTopic` is provisioned.
+Contains the underlying messaging infrastructure resources.
+*/
+type outputs = {resources: array<Adapter.resource>}
+
+/** A dictionary of event topic outputs keyed by aggregate name. */
+type allOutputs = dict<outputs>
+
+/**
+Publishes a single event as raw JSON to the event topic.
+
+- `string` — the aggregate ID (as a plain string)
+- `Message.meta` — the event envelope metadata
+- `JSON.t` — the serialized event payload
+*/
+type publishJson = (string, Reventless.Message.meta, JSON.t) => promise<unit>
+
+/**
+An item in a streaming event publication batch.
+Passed to `publishJsonStream` for high-throughput event pipelines.
+*/
+type publishJsonStreamItem = {
+  service: string,
+  meta: Reventless.Message.meta,
+  json: JSON.t,
+}
+
+/**
+Publishes a stream of event items as an `Effect.t`.
+Use this for high-throughput or streaming event pipelines.
+*/
+type publishJsonStream = Stream.t<publishJsonStreamItem, string, unit> => Effect.t<unit, string, unit>

package/src/components/EventTopic.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/components/Extension.res

@@ -0,0 +1,64 @@
+/**
+Deploy-time outputs produced when an `Extension` is provisioned.
+
+- `name` — the extension's logical name
+- `extensionPointName` — the extension point this extension connects to
+- `aggregateNames` — names of aggregates wired through this extension
+*/
+type outputs = {
+  name: string,
+  extensionPointName: string,
+  aggregateNames: array<string>,
+}
+
+// eventHandler type is defined in reventless (references Plugin.pluginDefinition which
+// would create a circular dependency: Extension → Plugin → Extension).
+// The spec-level T uses abstract `type operations` to avoid the cycle.
+
+/**
+Module type for a provisioned extension component.
+
+An `Extension` connects a host plugin's extension point to one or more aggregates,
+translating commands and events in both directions via `ExtensionMapping.Mapping`.
+
+`operations` is left abstract at the spec level to avoid a circular dependency.
+The concrete type is defined in the `reventless` package.
+*/
+module type T = {
+  type operations
+  type component
+  let make: (
+    ~publishToPluginExtensionPoint: CommandTopic.publishJsons,
+    ~publishToAggregates: dict<CommandTopic.publishJsons>,
+    ~readModelNamesForSourceName: dict<array<string>>,
+    ~publishToReadModels: dict<EventCollector.enqueueEvent>,
+    ~queryEngine: Reventless.QueryEngine.operations,
+    ~opts: option<Pulumi.ComponentResource.options>,
+  ) => component
+  let outputs: component => outputs
+  let operations: component => Pulumi.Output.t<operations>
+}
+
+/**
+Pre-build blueprint for an extension — compiled mappings that have not yet been
+instantiated as a Pulumi component.
+
+`Plugin.make` receives blueprints, groups them by extension point name,
+auto-merges mappings for the same EP, sets the component name to the plugin
+name, and builds the actual `Extension` component.
+*/
+module type Blueprint = {
+  module Spec: ExtensionMapping.Spec
+  module type Mapping = ExtensionMapping.T with module ExtensionPoint := Spec
+  let name: string
+  // npm-style specifier of the user extension file (the one declaring the
+  // `module Mapping`). Threaded from the user-facing Mapping.moduleUrl by
+  // Platform.Extension.Make so deploy-side helpers can emit HANDLER_CONFIG
+  // entries that let the runtime dynamic-import the user mapping at cold
+  // start.
+  let moduleUrl: string
+  // npm-style specifier of the Delegate (aggregate / slice) the extension
+  // delegates to. Threaded from Mapping.delegateModuleUrl by Platform.Extension.Make.
+  let delegateModuleUrl: string
+  let mappings: array<module(Mapping)>
+}

package/src/components/Extension.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/components/ExtensionPoint.res

@@ -0,0 +1,62 @@
+/**
+Deploy-time outputs produced when an `ExtensionPoint` is provisioned.
+
+- `name` — the extension point's logical name
+- `aggregateNames` — names of aggregates connected via `ExtensionPointMapping`
+- `commandTopic` — the inbound command queue for extensions to publish to
+- `eventTopic` — the outbound event topic extensions subscribe to
+*/
+type outputs = {
+  name: string,
+  aggregateNames: array<string>,
+  commandTopic: Pulumi.Output.t<CommandTopic.outputs>,
+  eventTopic: Pulumi.Output.t<EventTopic.outputs>,
+  // Module URLs preserved from the Spec and Mappings packed into Make. The
+  // EventCollector runtime needs them at HANDLER_CONFIG-build time to wire
+  // outgoing event publication for this extension point — see
+  // `Plugin_Helpers.registerEventCollectorContext` and the `extensionPointEntry`
+  // type that's serialised into the Lambda's HANDLER_CONFIG.
+  specModule: string,
+  mappingsModule: string,
+}
+
+// eventHandler type is defined in reventless (references Plugin.pluginDefinition which
+// would create a circular dependency: ExtensionPoint → Plugin → ExtensionPoint).
+// The infra-level T uses abstract `type operations` to avoid the cycle.
+
+/**
+A collection of `ExtensionPointMapping.T` modules connecting aggregates to
+this extension point.
+
+Pass a `Mappings` module to `Platform.ExtensionPoint.Make` to register all
+aggregate-to-extension-point connections.
+*/
+module type Mappings = {
+  module Spec: ExtensionPointMapping.Spec
+  module type Mapping = ExtensionPointMapping.T with module ExtensionPoint := Spec
+  let name: string
+  let moduleUrl: string
+  let mappings: array<module(Mapping)>
+}
+
+/**
+Module type for a provisioned extension point component.
+
+`operations` is left abstract to avoid a circular dependency between
+`ExtensionPoint`, `Plugin`, and back. The concrete type is defined in
+the `reventless` package.
+*/
+module type T = {
+  type operations
+  type component
+  let make: (
+    ~aggregateResources: dict<array<Adapter.resource>>,
+    ~publishToAggregates: dict<CommandTopic.publishJsons>,
+    ~scheduler: Scheduler.operations,
+    ~queryEngine: Reventless.QueryEngine.operations,
+    ~resourceNaming: ResourceNaming.operations,
+    ~opts: option<Pulumi.ComponentResource.options>,
+  ) => component
+  let outputs: component => outputs
+  let operations: component => Pulumi.Output.t<operations>
+}

package/src/components/ExtensionPoint.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/components/Heartbeat.res

@@ -0,0 +1,7 @@
+/**
+ * Deploy-time outputs produced when a `Heartbeat` component is provisioned.
+ *
+ * The heartbeat is an internal health-check component that periodically fires
+ * to verify that the plugin's Lambda handlers are reachable and warm.
+ */
+type outputs = {name: string, resources: array<Adapter.resource>}

package/src/components/Heartbeat.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/components/InboundTranslationSlice.res

@@ -0,0 +1,41 @@
+/**
+Deploy-time outputs produced when an `InboundTranslationSlice` is provisioned.
+
+- `resources` -- the underlying infrastructure
+- `queryDb` -- the DynamoDB table for the audit log
+*/
+type outputs = {
+  resources: array<Adapter.resource>,
+  queryDb: QueryDb.outputs,
+}
+
+/**
+Runtime operations exposed by an `InboundTranslationSlice` component.
+
+- `receive` -- accept external input, translate it, and publish a command
+*/
+type operations = {
+  receive: JSON.t => promise<result<array<string>, string>>,
+}
+
+/**
+Module type produced by `Platform.InboundTranslationSlice.Make(Spec)`.
+
+@example
+```rescript
+module PaymentWebhookSlice = Platform.InboundTranslationSlice.Make(PaymentWebhook)
+let slice = PaymentWebhookSlice.make(~publishJsons=publishJsonsOutput)
+```
+*/
+type t
+
+module type T = {
+  module Spec: Reventless.InboundTranslationSlice.Spec
+  module Translation: Reventless.InboundTranslationSlice.Translation with module Spec := Spec
+  type component = Component.t<t, outputs, operations>
+  let queryDbName: string
+  let make: (
+    ~publishJsons: Pulumi.Output.t<CommandTopic.publishJsons>,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

package/src/components/InboundTranslationSlice.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/components/OutboundTranslationSlice.res

@@ -0,0 +1,44 @@
+/**
+Deploy-time outputs produced when an `OutboundTranslationSlice` is provisioned.
+
+- `resources` -- the underlying infrastructure (e.g. SQS subscription)
+- `queryDb` -- the DynamoDB table for the TODO list
+*/
+type outputs = {
+  resources: array<Adapter.resource>,
+  queryDb: QueryDb.outputs,
+}
+
+/**
+Runtime operations exposed by an `OutboundTranslationSlice` component.
+
+- `enqueueEvent` -- push events into the slice's projection queue
+- `translatePending` -- manually trigger Phase 2 (useful in tests and for heartbeat)
+*/
+type operations = {
+  enqueueEvent: EventCollector.enqueueEvent,
+  translatePending: unit => promise<unit>,
+}
+
+/**
+Module type produced by `Platform.OutboundTranslationSlice.Make(Spec)`.
+
+@example
+```rescript
+module SendTrackingEmailSlice = Platform.OutboundTranslationSlice.Make(SendTrackingEmail)
+let slice = SendTrackingEmailSlice.make(~dcbEventLog=log, ~publishJsons=publishJsonsOutput)
+```
+*/
+type t
+
+module type T = {
+  module Spec: Reventless.OutboundTranslationSlice.Spec
+  module Translation: Reventless.OutboundTranslationSlice.Translation with module Spec := Spec
+  type component = Component.t<t, outputs, operations>
+  let queryDbName: string
+  let make: (
+    ~dcbEventLog: DcbEventLog.component,
+    ~publishJsons: Pulumi.Output.t<CommandTopic.publishJsons>,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

package/src/components/OutboundTranslationSlice.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/components/Plugin.res

@@ -0,0 +1,84 @@
+/**
+Deploy-time outputs produced by the `Plugin.T.make` function.
+
+All fields are `Pulumi.Output.t`-wrapped because they reference resources
+provisioned during the Pulumi stack update.
+*/
+type outputs = {
+  id: Pulumi.Output.t<string>,
+  version: Pulumi.Output.t<string>,
+  heartbeatInterval: Pulumi.Output.t<int>,
+  eventCollector: Pulumi.Output.t<EventCollector.outputs>,
+  extensionPoints: Pulumi.Output.t<dict<ExtensionPoint.outputs>>,
+  extensions: Pulumi.Output.t<dict<Extension.outputs>>,
+  aggregates: Pulumi.Output.t<dict<Aggregate.outputs>>,
+  readModels: Pulumi.Output.t<dict<ReadModel.outputs>>,
+  tasks: Pulumi.Output.t<dict<Task.outputs>>,
+  /** AppSync / GraphQL resolver resources. */
+  resolvers: Pulumi.Output.t<array<Adapter.resource>>,
+  heartbeat: Pulumi.Output.t<Heartbeat.outputs>,
+  apiSchemaFragment: Pulumi.Output.t<option<Reventless.Plugin.apiSchemaFragment>>,
+  /** UI fragment manifest for runtime micro-frontend registration (None for pure backend plugins). */
+  uiFragments: Pulumi.Output.t<option<Reventless.Plugin.uiFragmentManifest>>,
+  /** Plugin structure carrying queryable and writable component metadata (None for pure backend plugins). */
+  pluginStructure: Pulumi.Output.t<option<Reventless.Plugin.pluginStructure>>,
+  /** Present when the plugin uses a `DcbEventLog`. */
+  dcbEventLog: Pulumi.Output.t<option<DcbEventLog.outputs>>,
+  stateChangeSlices: Pulumi.Output.t<dict<StateChangeSlice.outputs>>,
+  stateViewSlices: Pulumi.Output.t<dict<StateViewSlice.outputs>>,
+  automationSlices: Pulumi.Output.t<dict<AutomationSlice.outputs>>,
+  outboundTranslationSlices: Pulumi.Output.t<dict<OutboundTranslationSlice.outputs>>,
+  inboundTranslationSlices: Pulumi.Output.t<dict<InboundTranslationSlice.outputs>>,
+}
+
+/**
+Module type for the top-level plugin factory.
+
+Call `Plugin.T.make` to provision all plugin components (aggregates, read models,
+tasks, extension points, extensions, heartbeat, DCB log) in a single Pulumi stack update.
+
+DCB slices are passed directly as optional labeled arrays. When any slice array
+is non-empty, a shared DCB EventLog is provisioned automatically.
+*/
+module type T = {
+  type api
+  type role
+  type component
+  let make: (
+    ~name: string,
+    /** How often (in seconds) the heartbeat Lambda fires. */
+    ~heartbeatInterval: int,
+    ~extensionPoints: array<module(ExtensionPoint.T)>=?,
+    ~extensions: array<module(Extension.Blueprint)>=?,
+    ~aggregates: array<module(Aggregate.T with type api = api)>=?,
+    ~readModels: array<module(ReadModel.T with type api = api and type role = role)>=?,
+    ~tasks: array<module(Task.T)>=?,
+    ~stateChangeSlices: array<module(StateChangeSlice.T)>=?,
+    ~stateViewSlices: array<module(StateViewSlice.T)>=?,
+    ~automationSlices: array<module(AutomationSlice.T)>=?,
+    ~outboundTranslationSlices: array<module(OutboundTranslationSlice.T)>=?,
+    ~inboundTranslationSlices: array<module(InboundTranslationSlice.T)>=?,
+    ~uiFragments: Reventless.Plugin.uiFragmentManifest=?,
+    ~pluginStructure: Reventless.Plugin.pluginStructure=?,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+  let makeAutoUIManifest: (
+    ~remoteEntryUrl: string,
+    ~name: string,
+    ~pluginStructure: Reventless.Plugin.pluginStructure,
+    ~readModelPositions: array<string>=?,
+    ~aggregatePositions: array<string>=?,
+  ) => Reventless.Plugin.uiFragmentManifest
+  let makePluginDefinition: (
+    ~name: string,
+    ~aggregates: array<module(Aggregate.T with type api = api)>=?,
+    ~readModels: array<module(ReadModel.T with type api = api and type role = role)>=?,
+    ~stateViewSlices: array<module(StateViewSlice.T)>=?,
+    ~stateChangeSlices: array<module(StateChangeSlice.T)>=?,
+    ~automationSlices: array<module(AutomationSlice.T)>=?,
+    ~outboundTranslationSlices: array<module(OutboundTranslationSlice.T)>=?,
+    ~inboundTranslationSlices: array<module(InboundTranslationSlice.T)>=?,
+    ~extensions: array<module(Extension.Blueprint)>=?,
+    ~extensionPoints: array<module(ExtensionPointMapping.Mapping)>=?,
+  ) => Reventless.Plugin.pluginStructure
+}

package/src/components/Plugin.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/components/QueryDb.res

@@ -0,0 +1,48 @@
+/**
+Errors that can occur during read model storage operations.
+
+Returned as the error variant in `Result.t` by read model operations that
+interact with the underlying query database (e.g. DynamoDB).
+*/
+@schema
+type storageError =
+  /** A write operation failed to persist the state. */
+  | NotSavedToStorage(string)
+  /** A read operation failed to retrieve the state. */
+  | NotLoadedFromStorage(string)
+  /** A count operation failed. */
+  | NotCountedOnStorage(string)
+  /** A delete operation failed. */
+  | NotDeletedFromStorage(string)
+  /** A batch write did not fully succeed (some items may not have been written). */
+  | BatchNotFullyWrittenToStorage(string)
+  /** A conditional write failed because the state was modified concurrently. */
+  | StaleState
+  /** A composite-key (sub-ID) operation was attempted but no sub-ID config was provided. */
+  | MissingSubIdConfig
+
+/**
+A function that derives the infrastructure resources needed to back GraphQL resolvers,
+given the set of all query database outputs in the plugin.
+*/
+type rec resolversResourcesMaker = dict<outputs> => array<Adapter.resource>
+
+/**
+Deploy-time outputs produced when a `QueryDb` is provisioned.
+
+- `resources` — the underlying database infrastructure resources
+- `resolversMaker` — callback used by the plugin to assemble resolver resources
+- `dataSourceName` — name of the AppSync DataSource that fronts this query DB.
+  Surfaced separately from `resources` so admin-side schema-push barriers can
+  wait for the DataSource to settle before invoking StartSchemaCreation —
+  AppSync rejects concurrent CreateDataSource / StartSchemaCreation calls
+  with `ConcurrentModificationException`.
+*/
+and outputs = {
+  resources: array<Adapter.resource>,
+  resolversMaker: resolversResourcesMaker,
+  dataSourceName: Pulumi.Output.t<string>,
+}
+
+/** A dictionary of query database outputs keyed by read model name. */
+type allOutputs = dict<outputs>

package/src/components/QueryDb.res.mjs

@@ -0,0 +1,33 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+let storageErrorSchema = S.union([
+  S.schema(s => ({
+    TAG: "NotSavedToStorage",
+    _0: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "NotLoadedFromStorage",
+    _0: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "NotCountedOnStorage",
+    _0: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "NotDeletedFromStorage",
+    _0: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "BatchNotFullyWrittenToStorage",
+    _0: s.m(S.string)
+  })),
+  S.literal("StaleState"),
+  S.literal("MissingSubIdConfig")
+]);
+
+export {
+  storageErrorSchema,
+}
+/* storageErrorSchema Not a pure module */

package/src/components/ReadModel.res

@@ -0,0 +1,50 @@
+/**
+Deploy-time outputs produced when a `ReadModel` is provisioned.
+
+- `name` — the read model's logical name
+- `queryDb` — the underlying query database outputs (DynamoDB table)
+- `eventCollector` — the inbound event queue
+- `sourceNames` — names of all aggregates whose events feed this read model
+*/
+type outputs = {
+  name: string,
+  queryDb: QueryDb.outputs,
+  eventCollector: Pulumi.Output.t<EventCollector.outputs>,
+  sourceNames: array<string>,
+}
+
+/**
+Runtime operations exposed by a `ReadModel` component.
+Used by the aggregate runtime to push events into the read model's event queue.
+*/
+type operations = {enqueueEvent: EventCollector.enqueueEvent}
+
+/**
+Module type produced by `Platform.ReadModel.Make(Spec, Mappings)`.
+
+@example
+```rescript
+// CatalogPlugin.res
+module CategoryReadModel = Platform.ReadModel.Make(CategoriesReadModel, CategoryMappings)
+
+let rm = CategoryReadModel.make(~api, ~apiRole, ~allEventTopics, ~opts=?)
+```
+*/
+module type T = {
+  module Spec: Reventless.ReadModel.Spec
+  type api
+  type role
+  type component
+  /** Names of aggregates whose events feed this read model (from Projection.Mapping.sourceName). */
+  let sourceNames: array<string>
+  let make: (
+    ~api: api,
+    ~apiRole: role,
+    ~allEventTopics: EventTopic.allOutputs,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+  let outputs: component => outputs
+  let operations: component => Pulumi.Output.t<operations>
+  /** Signal that all sources have been registered; finalises the read model. */
+  let finish: unit => unit
+}

package/src/components/ReadModel.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/components/Scheduler.res

@@ -0,0 +1,32 @@
+/**
+Deploy-time outputs produced when a `Scheduler` component is provisioned.
+Contains the single infrastructure resource backing the scheduler (e.g. EventBridge Scheduler).
+*/
+type outputs = {resource: Adapter.resource}
+
+/**
+Creates a schedule in the underlying scheduling service (e.g. EventBridge Scheduler).
+
+- `array<Adapter.resolvedResource>` — resolved scheduler resources (ARNs, etc.)
+- `Reventless.Schedule.schedule` — the schedule definition to create
+*/
+type createSchedule = (array<Adapter.resolvedResource>, Reventless.Schedule.schedule) => promise<unit>
+
+/**
+Deletes a schedule by name from the underlying scheduling service.
+
+- `array<Adapter.resolvedResource>` — resolved scheduler resources
+- `string` — the name of the schedule to delete
+*/
+type deleteSchedule = (array<Adapter.resolvedResource>, string) => promise<unit>
+
+/**
+Runtime operations exposed by a `Scheduler` component.
+
+Injected into extension points, tasks, and the plugin to create or delete
+schedules dynamically at runtime.
+*/
+type operations = {
+  createSchedule: createSchedule,
+  deleteSchedule: deleteSchedule,
+}

package/src/components/Scheduler.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/components/StateChangeSlice.res

@@ -0,0 +1,45 @@
+/**
+Deploy-time outputs produced when a `StateChangeSlice` is provisioned.
+Contains the underlying command queue infrastructure resources.
+*/
+type outputs = {
+  resources: array<Adapter.resource>,
+}
+
+/**
+Runtime operations exposed by a `StateChangeSlice` component.
+Used to publish commands to this slice's command topic.
+*/
+type operations = {publishJsons: CommandTopic.publishJsons}
+
+type t
+
+/**
+Module type produced by `Platform.StateChangeSlice.Make(Spec, Behavior)`.
+
+@example
+```rescript
+// CatalogPlugin.res
+module AddCategorySlice = Platform.StateChangeSlice.Make(AddCategory, AddCategory_Behavior)
+let slice = AddCategorySlice.make(~dcbEventLog=log, ~publishJsons=publishJsonsOutput)
+```
+*/
+module type T = {
+  module Spec: Reventless.StateChangeSlice.Spec
+  module Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec
+  /** `true` when built with `Platform.StateChangeSlice.MakeAsync` — uses FIFO channel, returns `CommandPending`. */
+  let isAsync: bool
+  type component = Component.t<t, outputs, operations>
+  let make: (
+    ~dcbEventLog: DcbEventLog.component,
+    ~publishJsons: Pulumi.Output.t<CommandTopic.publishJsons>,
+    /** Produced event-log type→tag-key map, used to drop vacuous (type, tag)
+        clause combinations when building the decision-model query. */
+    ~tagKeysByEventType: Dict.t<array<string>>=?,
+    /** Tag keys declared `@crossPartition` across the produced event schemas —
+        a cross-partition scalar command tag fans out into its own single-tag
+        decision-read clause. */
+    ~crossPartitionTagKeys: array<string>=?,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

package/src/components/StateChangeSlice.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/components/StateViewSlice.res

@@ -0,0 +1,38 @@
+/**
+Deploy-time outputs produced when a `StateViewSlice` is provisioned.
+
+- `resources` — the underlying infrastructure (e.g. SQS subscription)
+- `queryDb` — the DynamoDB table for querying projected state
+*/
+type outputs = {
+  resources: array<Adapter.resource>,
+  queryDb: QueryDb.outputs,
+}
+
+/**
+Runtime operations exposed by a `StateViewSlice` component.
+Used to push events into the slice's projection queue.
+*/
+type operations = {enqueueEvent: EventCollector.enqueueEvent}
+
+type t
+
+/**
+Module type produced by `Platform.StateViewSlice.Make(Spec, Projection)`.
+
+@example
+```rescript
+// CatalogPlugin.res
+module CategoriesViewSlice = Platform.StateViewSlice.Make(CategoriesView, CategoriesView_Projection)
+let slice = CategoriesViewSlice.make(~dcbEventLog=log)
+```
+*/
+module type T = {
+  module Spec: Reventless.StateViewSlice.Spec
+  module Projection: Reventless.StateViewSlice.Projection with module Spec := Spec
+  type component = Component.t<t, outputs, operations>
+  let make: (
+    ~dcbEventLog: DcbEventLog.component,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

package/src/components/StateViewSlice.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. */