@reventlessdev/reventless-spec 3.0.0-alpha.61

package/src/components/ReadModel.res

@@ -0,0 +1,199 @@
+/**
+Specifies how the sub-ID of a projected state row is supplied at query time.
+
+- `Field(name)` — the sub-ID comes from a field in the query response
+- `Argument(name)` — the sub-ID is passed as a GraphQL resolver argument
+- `NoSubId` — the read model has no sub-ID dimension
+*/
+type subId =
+  | Field(string)
+  | Argument(string)
+  | NoSubId
+
+/**
+Whether the GraphQL resolver field resolves to a single value or to a list.
+
+- `Single(fieldName)` — returns one item by ID
+- `Multi(fieldName)` — returns an array of items
+*/
+type resolvedField =
+  | Single(string)
+  | Multi(string)
+
+/** Source configuration for a single-ID GraphQL resolver. */
+type idResolverSourceConfig = {
+  idField: string,
+  subId: subId,
+  resolvedField: resolvedField,
+}
+
+/**
+Specifies which DynamoDB table field serves as the primary key in the resolver target.
+
+- `Index(indexName)` — resolve against an index using only the index ID
+- `IndexWithId(indexName, idField)` — resolve against an index with an explicit ID field
+- `Id` — resolve against the table's primary key
+*/
+type targetIdField =
+  | Index(string)
+  | IndexWithId(string, string)
+  | Id
+
+/** Target configuration for a single-ID GraphQL resolver. */
+type idResolverTargetConfig = {
+  pluginName?: string,
+  tableName: string,
+  idField: targetIdField,
+  subIdField?: string,
+}
+
+type resolveConfig<'source, 'target> = {
+  source: 'source,
+  target: 'target,
+}
+
+/** Configuration for a GraphQL resolver that resolves a single ID field. */
+type idResolverConfig = resolveConfig<idResolverSourceConfig, idResolverTargetConfig>
+
+/** Source configuration for a multi-ID (array) GraphQL resolver. */
+type idsResolverSourceConfig = {
+  idsField: string,
+  resolvedField: string,
+}
+
+/** Target configuration for a multi-ID (array) GraphQL resolver. */
+type idsResolverTargetConfig = {
+  pluginName?: string,
+  tableName: string,
+  subIdField?: string,
+}
+
+/** Configuration for a GraphQL resolver that resolves an array of ID fields. */
+type idsResolverConfig = resolveConfig<idsResolverSourceConfig, idsResolverTargetConfig>
+
+/** AppSync authorization rule associating a DynamoDB table with a Cognito group. */
+type authorization = {
+  tableName: string,
+  group: string,
+}
+
+/** How much of a DynamoDB global secondary index is projected into the index. */
+type projectionType = KEYS_ONLY | ALL | INCLUDE(array<string>)
+
+/**
+Configuration for a DynamoDB Global Secondary Index on a read model table.
+
+- `index` — the index name
+- `type_` — the DynamoDB attribute type of the index key (`"S"`, `"N"`, etc.)
+- `idField` / `subIdField` — index key field overrides (set to synthetic `_name_pk`/`_name_sk` for composite keys)
+- `pkFields` / `skFields` — source state field names for composite pk/sk; runtime uses these to compute synthetic attribute values
+- `pkSep` / `skSep` — separator for composite pk/sk concatenation (default `"/"`)
+- `projectionType` — which attributes are projected into the index
+- `authorization` — optional AppSync authorization rule
+*/
+type indexConfig = {
+  index: string,
+  type_: string,
+  idField?: string,
+  subIdField?: string,
+  pkFields?: array<string>,
+  pkSep?: string,
+  skFields?: array<string>,
+  skSep?: string,
+  projectionType: projectionType,
+  authorization?: authorization,
+}
+
+/**
+Composite-key configuration for a read model that has both a primary ID and a sub-ID.
+
+- `subIdField` — the DynamoDB range-key attribute name
+- `getSubId` — extracts the sub-ID string from a projected state value
+*/
+type subIdConfig<'state> = {
+  subIdField: string,
+  getSubId: 'state => string,
+}
+
+/**
+Infrastructure configuration for a read model.
+
+- `idResolvers` — GraphQL resolvers for single-ID lookups
+- `idsResolvers` — GraphQL resolvers for multi-ID (array) lookups
+- `indexes` — additional DynamoDB global secondary indexes
+
+Use the `config` factory function to build this with defaults.
+*/
+type config = {
+  idResolvers: array<idResolverConfig>,
+  idsResolvers: array<idsResolverConfig>,
+  indexes: array<indexConfig>,
+}
+
+/**
+Builds a `ReadModel.config` with all optional fields defaulting to empty arrays.
+
+@example
+```rescript
+// CategoriesReadModel.res
+let config = ReadModel.config()
+```
+*/
+let config = (~idResolvers=[], ~idsResolvers=[], ~indexes=[]) => {
+  idResolvers,
+  idsResolvers,
+  indexes,
+}
+
+/**
+Module type for a read model's identity and schema specification.
+
+@example
+```rescript
+// CategoriesReadModel.res
+module Id = Id.String
+let name = "Categories"
+
+@schema
+type state = {categoryId: string, name: string, archived: bool}
+
+let config = ReadModel.config()
+let subIdConfig = None
+```
+*/
+module type Spec = {
+  module Id: Id.T
+
+  /** Logical read model name, used as the DynamoDB table-name prefix. */
+  let name: string
+  let moduleUrl: string
+
+  /** The projected state type stored in the read model. Must carry `@schema`. */
+  @schema
+  type state
+
+  /** Sury schema for the state type — generated automatically by `@schema`. */
+  let stateSchema: S.t<state>
+
+  /** Infrastructure configuration (indexes, resolvers). */
+  let config: config
+
+  /** Optional composite-key configuration. `None` for single-key tables. */
+  let subIdConfig: option<subIdConfig<state>>
+
+  /** Authorization rule evaluated at the GraphQL resolver entry before any
+      query is resolved. Auto-injected by `@@reventless.spec` and on
+      structurally-detected inline spec modules — defaults to
+      `AllowAuthenticated`; override at the file/module level with
+      `@@reventless.authorize(<rule>)`. */
+  let authorization: Authorization.permission
+
+  /** AutoUI visibility hint. Auto-injected by `@@reventless.spec` and on
+      structurally-detected inline spec modules — defaults to
+      `Visibility.Public`; override at the file/module level with
+      `@@reventless.visibility(Internal)` to hide from the AutoUI manifest.
+      Does not affect GraphQL exposure, authorization, or resolver
+      provisioning. */
+  let visibility: Visibility.t
+}
+

package/src/components/ReadModel.res.mjs

@@ -0,0 +1,18 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function config(idResolversOpt, idsResolversOpt, indexesOpt) {
+  let idResolvers = idResolversOpt !== undefined ? idResolversOpt : [];
+  let idsResolvers = idsResolversOpt !== undefined ? idsResolversOpt : [];
+  let indexes = indexesOpt !== undefined ? indexesOpt : [];
+  return {
+    idResolvers: idResolvers,
+    idsResolvers: idsResolvers,
+    indexes: indexes
+  };
+}
+
+export {
+  config,
+}
+/* No side effect */

package/src/components/Reference.res

@@ -0,0 +1,51 @@
+/** Identifies which entity a reference field points to. */
+type target = {entity: string, plugin: option<string>}
+
+/** Sury metadata ID for entity reference annotation. */
+let referenceId: S.Metadata.Id.t<target> = S.Metadata.Id.make(~namespace="reventless", ~name="reference")
+
+/**
+A sury string schema annotated as an entity reference field.
+
+Use with `@s.matches(Reference.to_("EntityName"))` on command/event fields that
+carry a foreign-entity ID. Also implies DCB tag semantics so the field is
+automatically queryable in DCB event logs.
+
+Pass `~key` to override the DCB tag key (defaults to the field name). The
+`@ref` ppx shorthand supplies it automatically for plural `*Ids: array<string>`
+fields (singularizing, e.g. `productIds` → tag key `productId`) so they share a
+tag key with their singular-named producer events.
+
+Prefer the `@ref("EntityName")` ppx shorthand over writing `@s.matches(...)` by hand.
+
+@example
+```rescript
+@schema type command =
+  | PlaceOrder({
+      orderId: @s.matches(DcbTag.string) string,
+      customerId: @s.matches(Reference.to_("Customer")) string,
+    })
+```
+*/
+let to_ = (~plugin=?, ~key=?, entity: string): S.t<string> => {
+  let base =
+    S.string
+    ->S.Metadata.set(~id=DcbTag.dcbTagId, true)
+    ->S.Metadata.set(~id=referenceId, {entity, plugin})
+  switch key {
+  | Some(k) => base->S.Metadata.set(~id=DcbTag.dcbTagKeyOverrideId, k)
+  | None => base
+  }
+}
+
+/** Returns the reference target if the schema carries `Reference.to_(...)` metadata. */
+let getTarget = (schema: S.t<unknown>): option<target> =>
+  S.Metadata.get(schema, ~id=referenceId)
+
+/**
+Like `to_` but does not imply DCB tag semantics.
+Use with `@ref("Entity") @noDcbTag` when the field references another entity
+but should not participate in content-based event routing.
+*/
+let toWithoutDcbTag = (~plugin=?, entity: string): S.t<string> =>
+  S.string->S.Metadata.set(~id=referenceId, {entity, plugin})

package/src/components/Reference.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "./DcbTag.res.mjs";
+
+let referenceId = S.Metadata.Id.make("reventless", "reference");
+
+function to_(plugin, key, entity) {
+  let base = S.Metadata.set(S.Metadata.set(S.string, DcbTag$Reventless.dcbTagId, true), referenceId, {
+    entity: entity,
+    plugin: plugin
+  });
+  if (key !== undefined) {
+    return S.Metadata.set(base, DcbTag$Reventless.dcbTagKeyOverrideId, key);
+  } else {
+    return base;
+  }
+}
+
+function getTarget(schema) {
+  return S.Metadata.get(schema, referenceId);
+}
+
+function toWithoutDcbTag(plugin, entity) {
+  return S.Metadata.set(S.string, referenceId, {
+    entity: entity,
+    plugin: plugin
+  });
+}
+
+export {
+  referenceId,
+  to_,
+  getTarget,
+  toWithoutDcbTag,
+}
+/* referenceId Not a pure module */

package/src/components/StateAnnotations.res

@@ -0,0 +1,65 @@
+/**
+Spec describing the structural annotations declared on the fields of an
+`@schema type state` record. The ppx attaches one of these to the generated
+`stateSchema` whenever a field carries a structural annotation (`@id`,
+`@compositeId`, `@subId`, `@compositeSubId`, `@index`), a visibility
+annotation (`@hidden`, `@summary`), a hierarchical-rendering annotation
+(`@drillTarget`, `@collapsed`), or a server-query opt-in annotation
+(`@scan`, `@scanSort`). Downstream consumers (UI, MCP, codegen) read the
+spec to surface field roles in JSON Schema as `x-reventless-*` extension
+properties.
+
+Each list contains the source field names; `indexes` carries `(fieldName,
+indexName)` pairs where `indexName` is `""` for unnamed `@index` annotations.
+`hidden` lists fields the UI should suppress from summary/list views;
+`summary` lists fields the UI should always include in summary/list views.
+`drillTargets` carries `(fieldName, sliceName)` pairs naming the slice/view
+the UI should navigate to instead of expanding the field inline;
+`drillTargetKeys` carries `(fieldName, keyPath)` pairs for fields whose
+drill-down target is keyed by a sub-path within the array element;
+`collapsed` lists object-typed fields the UI should render as an inline
+summary rather than expanding. `scan` lists fields the type author opted
+into server-side equality filtering on (without a backing index); `scanSort`
+lists fields the type author opted into server-side sorting on. The cost is
+free on the in-memory adapter but is `O(n)` Scan + FilterExpression on
+DynamoDB-backed adapters — the annotation is the explicit signal that the
+read model is small enough or the cost is acceptable.
+*/
+type stateAnnotationSpec = {
+  ids: array<string>,
+  compositeIds: array<string>,
+  subIds: array<string>,
+  compositeSubIds: array<string>,
+  indexes: array<(string, string)>,
+  hidden: array<string>,
+  summary: array<string>,
+  drillTargets: array<(string, string)>,
+  drillTargetKeys: array<(string, string)>,
+  collapsed: array<string>,
+  scan: array<string>,
+  scanSort: array<string>,
+  /**
+  Field annotated `@status` on the state record (PPX-emitted). `Some(name)`
+  when one such annotation exists; the PPX errors on duplicate `@status`
+  annotations within the same record. Codegen consumes this to populate
+  `queryableDef.statusField` (with a fallback to a field literally named
+  `"status"` when this annotation is absent).
+  */
+  status: option<string>,
+  /**
+  Component-level visibility hint from `@@reventless.visibility(...)`.
+  `Some("Internal")` when the file-level attribute is `Internal`; `None`
+  (omitted) for the default `Public`. `SuryToJsonSchema.deriveObjectSchema`
+  emits `x-reventless-visibility: "Internal"` on the schema when present —
+  the default case is omitted to keep schemas compact.
+  */
+  visibility: option<string>,
+}
+
+/** Sury metadata ID used to attach a `stateAnnotationSpec` to a state schema. */
+let stateAnnotationsId: S.Metadata.Id.t<stateAnnotationSpec> =
+  S.Metadata.Id.make(~namespace="reventless", ~name="stateAnnotations")
+
+/** Returns the spec attached to a state schema, if any. */
+let getSpec = (schema: S.t<unknown>): option<stateAnnotationSpec> =>
+  S.Metadata.get(schema, ~id=stateAnnotationsId)

package/src/components/StateAnnotations.res.mjs

@@ -0,0 +1,15 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+let stateAnnotationsId = S.Metadata.Id.make("reventless", "stateAnnotations");
+
+function getSpec(schema) {
+  return S.Metadata.get(schema, stateAnnotationsId);
+}
+
+export {
+  stateAnnotationsId,
+  getSpec,
+}
+/* stateAnnotationsId Not a pure module */

package/src/components/StateChangeSlice.res

@@ -0,0 +1,131 @@
+/**
+Module types for a DCB write-side state change slice.
+
+A `StateChangeSlice` is the DCB equivalent of an aggregate: it processes
+commands by reading the relevant events from a shared `DcbEventLog`, building
+a `state` (ephemeral read model), and appending new events conditioned
+on no concurrent changes to the same entities.
+
+Plan 02 splits the merged spec into two module types:
+
+- `Spec` — types, identity, schemas. The structural contract.
+- `Behavior` — `state`, `initialState`, `evolve`, `decide`. The state machine.
+
+@example
+```rescript
+// AddCategory.res
+let name = "AddCategory"
+
+type state = {exists: bool, archived: bool}
+let initialState = {exists: false, archived: false}
+
+@schema type consumedEvent =
+  | CategoryAdded
+  | CategoryArchived
+
+let evolve = (state, event) => switch event {
+  | CategoryAdded => {exists: true, archived: false}
+  | CategoryArchived => {...state, archived: true}
+}
+
+@schema type command = AddCategory({categoryId: @s.matches(DcbTag.string) string, name: string})
+@schema type error = CategoryAlreadyExists
+
+@schema type event =
+  | CategoryAdded({categoryId: @s.matches(DcbTag.string) string, name: string})
+
+let decide = (state, command) => switch command {
+  | AddCategory({categoryId, name}) =>
+    if state.exists { Error(CategoryAlreadyExists) }
+    else { Ok([CategoryAdded({categoryId, name})]) }
+}
+```
+*/
+
+/**
+The lean Spec for a StateChangeSlice — types, identity, schemas. State and
+state-evolution functions live in the sibling `Behavior` module type.
+*/
+module type Spec = {
+  /** Logical name of this slice (used as a command topic prefix). */
+  let name: string
+  let moduleUrl: string
+
+  /** Identity type — always `Id.String` for DCB slices. */
+  module Id: Id.T
+
+  /**
+  Events this slice reads to build its decision model (in `evolve`).
+  Only needs the fields required for the decision — no tag annotations needed.
+  May be payload-less for events where only existence matters.
+  Must carry `@schema`.
+  */
+  @schema
+  type consumedEvent
+
+  /** Commands this slice handles. Must carry `@schema`. */
+  @schema
+  type command
+
+  /** Business rule violation errors. Must carry `@schema`. */
+  @schema
+  type error
+
+  /** Events this slice emits (from `decide`). Must carry `@schema` and include tag annotations. */
+  @schema
+  type event
+
+  /** Schema for the command type — used to extract DCB tags for the conditional read. */
+  let commandSchema: S.t<command>
+
+  /** Authorization rule evaluated at the GraphQL resolver entry before any
+      command is dispatched. Auto-injected by `@@reventless.spec` and on
+      structurally-detected inline spec modules — defaults to
+      `AllowAuthenticated`; override at the file/module level with
+      `@@reventless.authorize(<rule>)`. */
+  let commandAuthorization: command => Authorization.permission
+
+  /** Decision-read consistency mode for this slice's optimistic-concurrency
+      retry loop. Auto-injected by `@@reventless.spec` and on
+      structurally-detected inline spec modules — defaults to
+      `EscalateOnRetry` (eventual first, strong on retry); override at the
+      file/module level with `@@reventless.consistency(AlwaysStrong)` (or
+      `AlwaysEventual`). Affects RCU/latency only, never correctness — the
+      conditional append's fence is always evaluated strongly. */
+  let readConsistency: ReadConsistency.t
+}
+
+/**
+The Behavior — pure state machine that decides commands and folds events.
+
+`module Spec: Spec` shares the lean Spec's types so `evolve` references
+`Spec.consumedEvent`, `decide` references `Spec.command`/`Spec.event`/`Spec.error`.
+*/
+module type Behavior = {
+  module Spec: Spec
+
+  /**
+  The ephemeral state built by replaying relevant events.
+  Not persisted — reconstructed for each command by reading from the DCB log.
+  */
+  type state
+
+  /** The initial (empty) state before any events have been applied. */
+  let initialState: state
+
+  /**
+  Folds one consumed event into the state during the read phase.
+  Must be a pure function — no side effects.
+  */
+  let evolve: (state, Spec.consumedEvent) => state
+
+  /**
+  Decides what events to append given the current state and the command.
+  Return `Ok(events)` to append, or `Error(error)` to reject the command.
+  */
+  let decide: (state, Spec.command) => result<array<Spec.event>, Spec.error>
+
+  /** File URL of this Behavior module (`import.meta.url`). */
+  let moduleUrl: string
+}
+

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,99 @@
+/**
+Module types for a DCB read-side state view slice.
+
+A `StateViewSlice` is the DCB equivalent of a `ReadModel`: it listens to the
+shared `DcbEventLog` event topic and projects events into a queryable state table
+using the `Projection.action` algebra.
+
+Plan 02 splits the merged spec into two module types:
+
+- `Spec` — types, identity, schemas, infrastructure config. The persisted
+  state contract (matches the ReadModel convention where `state` is in Spec).
+- `Projection` — the single `project` function (and any future projection
+  helpers).
+
+@example
+```rescript
+// CategoriesView.res
+let name = "CategoriesView"
+
+@schema type state = {categoryId: string, name: string, archived: bool}
+
+@schema type consumedEvent =
+  | CategoryAdded({categoryId: string, name: string})
+  | CategoryRenamed({categoryId: string, name: string})
+  | CategoryArchived({categoryId: string})
+
+let project = event => switch event {
+  | CategoryAdded({categoryId, name}) =>
+    [Set(categoryId, {categoryId, name, archived: false})]
+  | CategoryRenamed({categoryId, name}) =>
+    [Update(categoryId, state => {...state, name})]
+  | CategoryArchived({categoryId}) =>
+    [Update(categoryId, state => {...state, archived: true})]
+}
+```
+*/
+
+/**
+The lean Spec for a StateViewSlice — types, identity, schemas, infra config.
+Per D2, `state` lives here (not in `Projection`) because the projected state
+is the externally-observable contract — schema queried by GraphQL resolvers.
+*/
+module type Spec = {
+  /** Logical name of this view slice (used as a DynamoDB table prefix). */
+  let name: string
+  let moduleUrl: string
+
+  /** The projected state type stored in the view table. Must carry `@schema`. */
+  @schema
+  type state
+
+  /** Sury schema for the state type — generated automatically by `@schema`. */
+  let stateSchema: S.t<state>
+
+  /**
+  Events this view slice projects. Only needs the fields required for the projection —
+  no tag annotations needed. May be payload-less where only existence matters.
+  Must carry `@schema`.
+  */
+  @schema
+  type consumedEvent
+
+  /** Infrastructure configuration (indexes, resolvers). */
+  let config: ReadModel.config
+
+  /** Optional composite-key configuration. `None` for single-key tables. */
+  let subIdConfig: option<ReadModel.subIdConfig<state>>
+
+  /** Authorization rule evaluated at the GraphQL resolver entry before any
+      query is resolved. Auto-injected by `@@reventless.spec` and on
+      structurally-detected inline spec modules — defaults to
+      `AllowAuthenticated`. */
+  let authorization: Authorization.permission
+
+  /** AutoUI visibility hint. Auto-injected by `@@reventless.spec` and on
+      structurally-detected inline spec modules — defaults to
+      `Visibility.Public`; override at the file/module level with
+      `@@reventless.visibility(Internal)` to hide from the AutoUI manifest.
+      Does not affect GraphQL exposure, authorization, or resolver
+      provisioning. */
+  let visibility: Visibility.t
+}
+
+/**
+The Projection — the pure projection function from consumed events to actions.
+*/
+module type Projection = {
+  module Spec: Spec
+
+  /**
+  Projects one consumed event into read model actions.
+  Receives only events declared in `Spec.consumedEvent` — no wildcard needed.
+  */
+  let project: Spec.consumedEvent => array<Projection.action<string, Spec.state>>
+
+  /** File URL of this Projection module (`import.meta.url`). */
+  let moduleUrl: string
+}
+

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. */

package/src/components/Task.res

@@ -0,0 +1,62 @@
+/**
+Derives the name used to query a task's S3 bucket.
+
+- `~taskName` — the task's logical name
+- `~bucketName` — optional override; defaults to the task's configured bucket name
+*/
+type queryBucketName = (~taskName: string, ~bucketName: string=?) => string
+
+/**
+An action that a task handler can return after processing a trigger.
+
+- `PublishCommands(aggregateName, commands)` — publish commands to an aggregate
+- `CreateSchedule(schedule)` — create a new recurring or one-time schedule
+- `DeleteSchedule(name)` — delete a schedule by name
+*/
+type taskAction =
+  | PublishCommands(string, array<Message.commandJson>)
+  | CreateSchedule(Schedule.schedule)
+  | DeleteSchedule(string)
+
+/**
+A callback invoked when an S3 object event occurs on a task bucket.
+
+- `~eventName` — the S3 event type (e.g. `"ObjectCreated:Put"`)
+- `~key` — the S3 object key that triggered the event
+
+Returns an array of `taskAction` values to execute after the callback completes.
+*/
+type bucketCallback = (~eventName: string, ~key: string) => promise<array<taskAction>>
+
+/**
+The access mode a task needs for one of its S3 buckets.
+
+- `Read` — task reads from the bucket (e.g. to import catalog data)
+- `Write` — task writes to the bucket (e.g. to export a report)
+- `ReadWrite` — task reads and writes
+*/
+type bucketMode = Read | Write | ReadWrite
+
+/**
+Configuration for one S3 bucket used by a task.
+
+- `bucketName` — optional override; if absent, the framework derives a name
+- `bucketMode` — the required access level
+- `callback` — optional handler triggered by S3 object events
+*/
+type bucketSpec = {bucketName?: string, bucketMode: bucketMode, callback?: bucketCallback}
+
+/** An array of `SideEffect.T` modules executed when this task fires. */
+type sideEffects = array<module(SideEffect.T)>
+
+/**
+The runtime configuration returned by a task's `setup` function.
+
+- `buckets` — optional list of S3 bucket specifications
+- `sideEffects` — optional list of side effect modules to execute
+*/
+type config = {
+  buckets?: array<bucketSpec>,
+  sideEffects?: sideEffects,
+}
+

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