@reventlessdev/reventless-core 3.0.0-alpha.301 → 3.0.0-alpha.302

package/src/components/CommandTopic/CommandTopic_Adapter.res

@@ -12,7 +12,7 @@ and channel<'callbackEvent, 'context, 'channelParts, 'runtimeParts> = {
   publishJsonsStream: Pulumi.Output.t<ReventlessInfra.CommandTopic.publishJsonsStream>,
   publishJsonsAndWait: Pulumi.Output.t<option<CommandTopic.publishJsonsAndWait>>,
   handleChannelEvent: CommandTopic.jsonCommandsHandler => Pulumi.Output.t<
-    Runtime.effectHandler<'callbackEvent, 'context, unit, string>,
+    Runtime.effectInvocationHandler<'callbackEvent, 'context, unit, string>,
   >,
   connect: connect<'callbackEvent, 'context, 'channelParts, 'runtimeParts>,
 }

package/src/components/EventCollector/EventCollector.res

@@ -24,7 +24,7 @@ module type T = {
   let makeHandler: (
     ~eventCollector: component,
     ~jsonEventsHandler: jsonEventsHandler,
-  ) => Pulumi.Output.t<Runtime.effectHandler<callbackEvent, 'context, unit, string>>
+  ) => Pulumi.Output.t<Runtime.effectInvocationHandler<callbackEvent, 'context, unit, string>>
 
   let make: (
     ~name: string,

package/src/components/EventCollector/EventCollector_Adapter.res

@@ -3,7 +3,7 @@ type channel<'callbackEvent, 'context, 'channelParts> = {
   resources: array<ReventlessInfra.Adapter.resource>,
   enqueueEvent: Pulumi.Output.t<EventCollector.enqueueEvent>,
   handleChannelEvent: EventCollector.jsonEventsHandler => Pulumi.Output.t<
-    Runtime.effectHandler<'callbackEvent, 'context, unit, string>,
+    Runtime.effectInvocationHandler<'callbackEvent, 'context, unit, string>,
   >,
 }
 

package/src/components/Heartbeat/Heartbeat.res

@@ -19,7 +19,7 @@ module type T = {
     ~id: string,
     ~timeout: int,
     ~publishToPluginExtensionPoint: CommandTopic.publishJsons,
-  ) => Pulumi.Output.t<Runtime.eventHandler<unit, 'context, unit>>
+  ) => Pulumi.Output.t<Runtime.invocationHandler<unit, 'context, unit>>
 
   let make: (~name: string, ~opts: Pulumi.ComponentResource.options=?) => component
 }

package/src/components/ReadModel/ReadModel.res

@@ -23,7 +23,7 @@ module type T = {
   /** Bare event-variant names consumed across every projection mapping's source event
       schema — names the actual events (so a DCB-log-sourced mapping is captured), unlike
       `sourceNames` which only lists source aggregate / DCB-log names. Surfaced by
-      Plugin_Structure as `queryableDef.consumedEventTypes`. */
+      Plugin_Structure as `readSideDef.consumedEventTypes`. */
   let consumedEventNames: array<string>
   let outputs: component => outputs
   let operations: component => Pulumi.Output.t<operations>

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -132,8 +132,8 @@ module Make = (
                     })->Array.map(
                       Reventless.Projection.mapActionId(
                         _,
-                        ~to_=Spec.Key.toString,
-                        ~from=Spec.Key.makeFromString,
+                        ~to_=Spec.Id.toString,
+                        ~from=Spec.Id.makeFromString,
                       ),
                     ) catch {
                     | exn =>

package/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs

@@ -109,7 +109,7 @@ function Make(RuntimeEnvironment) {
                   event: Primitive_option.valFromOption(event),
                   meta: meta,
                   recordedAt: recordedAt
-                }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Key.toString, Spec.Key.makeFromString));
+                }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Id.toString, Spec.Id.makeFromString));
               } catch (raw_exn) {
                 let exn$1 = Primitive_exceptions.internalToException(raw_exn);
                 let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$1), Stdlib_JsExn.message), "unknown");

package/src/components/StateViewSlice/StateViewSlice_Callback.res

@@ -44,8 +44,8 @@ module Make = (
           Projection.project({event, meta: raw.meta, recordedAt: raw.recordedAt})->Array.map(
             Reventless.Projection.mapActionId(
               _,
-              ~to_=Spec.Key.toString,
-              ~from=Spec.Key.makeFromString,
+              ~to_=Spec.Id.toString,
+              ~from=Spec.Id.makeFromString,
             ),
           )
         let actionsStr = LogFormat.actionNames(actions)

package/src/components/StateViewSlice/StateViewSlice_Callback.res.mjs

@@ -33,7 +33,7 @@ function Make(Spec) {
           event: event,
           meta: raw.meta,
           recordedAt: raw.recordedAt
-        }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Key.toString, Spec.Key.makeFromString));
+        }).map(__x => Projection$Reventless.mapActionId(__x, Spec.Id.toString, Spec.Id.makeFromString));
         let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
         Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, raw.data, `handling event ` + idx.contents.toString() + `/` + count + `: ` + LogFormat$ReventlessCore.bold(raw.eventType) + `(` + id + `) ` + actionsStr));
         allActions.push(...actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, raw.meta.time, Spec.stateSchema)));

package/src/components/Task/Task_Adapter.res

@@ -24,7 +24,7 @@ module type Bucket = {
   type bucketParts
 
   let connect: connect<bucketParts, runtimeParts>
-  let makeHandler: Task.bucketCallback => Runtime.eventHandler<
+  let makeHandler: Task.bucketCallback => Runtime.invocationHandler<
     callbackEvent,
     context,
     array<Task.taskAction>,

package/src/components/Task/Task_Builder.res

@@ -97,7 +97,7 @@ module Make = (
 ): Task.T => {
   module Spec = Spec
   type component = Task.component
-  // type handler = Runtime.eventHandler<
+  // type handler = Runtime.invocationHandler<
   //   TaskRuntimeBuilder.callbackEvent,
   //   TaskRuntimeBuilder.context,
   //   array<Task.taskAction>,

package/src/plugin/component/Plugin_Builder.res

@@ -1050,31 +1050,31 @@ module Make = (
     ~aggregatePositions: array<string>=[],
   ): Reventless.Plugin.uiFragmentManifest => {
     // Internal queryable components are hidden from the AutoUI manifest. They
-    // remain fully wired (resolvers, GraphQL schema, queryable defs,
+    // remain fully wired (resolvers, GraphQL schema, read-side defs,
     // authorization) — visibility is a UX hint, not a security boundary. See
     // docs/plans/done/component-visibility-annotations.md
-    let isVisibleQueryable = (q: Reventless.Plugin.queryableDef) =>
+    let isVisibleReadSide = (q: Reventless.Plugin.readSideDef) =>
       switch q.visibility {
       | Some("Internal") => false
       | _ => true
       }
-    let visibleReadModels = pluginStructure.readModels->Array.filter(isVisibleQueryable)
-    let visibleStateViewSlices = pluginStructure.stateViewSlices->Array.filter(isVisibleQueryable)
-    let listPanel = (q: Reventless.Plugin.queryableDef): Reventless.Plugin.panelManifestEntry => {
+    let visibleReadModels = pluginStructure.readModels->Array.filter(isVisibleReadSide)
+    let visibleStateViewSlices = pluginStructure.stateViewSlices->Array.filter(isVisibleReadSide)
+    let listPanel = (q: Reventless.Plugin.readSideDef): Reventless.Plugin.panelManifestEntry => {
       fragmentId: name ++ "." ++ q.name ++ ".list",
       title: q.name,
       description: "",
       positions: readModelPositions,
       requiredAccess: None,
     }
-    let detailPanel = (w: Reventless.Plugin.writableDef): Reventless.Plugin.panelManifestEntry => {
+    let detailPanel = (w: Reventless.Plugin.writeSideDef): Reventless.Plugin.panelManifestEntry => {
       fragmentId: name ++ "." ++ w.name ++ ".detail",
       title: w.name,
       description: "",
       positions: aggregatePositions,
       requiredAccess: None,
     }
-    let listPage = (q: Reventless.Plugin.queryableDef): Reventless.Plugin.pageManifestEntry => {
+    let listPage = (q: Reventless.Plugin.readSideDef): Reventless.Plugin.pageManifestEntry => {
       fragmentId: name ++ "." ++ q.name ++ ".list",
       title: q.name,
       menuEntry: {label: q.name, icon: None, group: None, sortOrder: 0},

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

@@ -47,7 +47,7 @@ function Make(Spec) {
     let makeAutoUIManifest = (remoteEntryUrl, name, pluginStructure, readModelPositionsOpt, aggregatePositionsOpt) => {
       let readModelPositions = readModelPositionsOpt !== undefined ? readModelPositionsOpt : [];
       let aggregatePositions = aggregatePositionsOpt !== undefined ? aggregatePositionsOpt : [];
-      let isVisibleQueryable = q => {
+      let isVisibleReadSide = q => {
         let match = q.visibility;
         if (match !== undefined) {
           return match !== "Internal";
@@ -55,8 +55,8 @@ function Make(Spec) {
           return true;
         }
       };
-      let visibleReadModels = pluginStructure.readModels.filter(isVisibleQueryable);
-      let visibleStateViewSlices = pluginStructure.stateViewSlices.filter(isVisibleQueryable);
+      let visibleReadModels = pluginStructure.readModels.filter(isVisibleReadSide);
+      let visibleStateViewSlices = pluginStructure.stateViewSlices.filter(isVisibleReadSide);
       let listPanel = q => ({
         fragmentId: name + "." + q.name + ".list",
         title: q.name,

package/src/plugin/component/Plugin_BuiltHook.res

@@ -97,7 +97,7 @@ type pluginDeployedSchema = {
   /** Intra-plugin grouping band (the "chapter") this component belongs to, mirrored
    from the static `pluginStructure` for parity on the hook surface. Absent when the
    component carries no chapter (lives directly under a kind-folder). See
-   `Reventless.Plugin.queryableDef.chapter`. */
+   `Reventless.Plugin.readSideDef.chapter`. */
   chapter?: string,
 }
 

package/src/plugin/component/Plugin_Structure.res

@@ -392,13 +392,13 @@ let extensionPartitionFailure = (
 // forces a spec to pick its linked view's enum.
 let checkDeclaredTransitions = (
   ~pluginName: string,
-  ~writables: array<Reventless.Plugin.writableDef>,
+  ~writeSides: array<Reventless.Plugin.writeSideDef>,
   ~lifecycleStatesByView: dict<array<string>>,
 ): unit => {
   let unvalidated = ref(0)
   let failures = []
 
-  writables->Array.forEach(w =>
+  writeSides->Array.forEach(w =>
     w.commands->Array.forEach(cmd => {
       let declared = Array.concat(
         cmd.allowedStates->Option.getOr([]),
@@ -469,7 +469,7 @@ let checkDeclaredTransitions = (
 // and one that stops a deploy gets silenced rather than fixed. Pure, so the rule
 // tests without a log; `checkLifecycleTopology` reports.
 let lifecycleTopologyFindings = (
-  ~writables: array<Reventless.Plugin.writableDef>,
+  ~writeSides: array<Reventless.Plugin.writeSideDef>,
   ~lifecycleStatesByView: dict<array<string>>,
 ): array<(string, string)> => {
   let findings = []
@@ -479,7 +479,7 @@ let lifecycleTopologyFindings = (
     // Arrival only, so a creating command (a target and no from-set) counts
     // towards reachability like any other edge.
     let reachable =
-      writables->Array.reduce([], (acc, w) =>
+      writeSides->Array.reduce([], (acc, w) =>
         w.linkedViews->Array.includes(view)
           ? Array.concat(acc, w.commands->Array.filterMap(cmd => cmd.targetState))
           : acc
@@ -508,10 +508,10 @@ let lifecycleTopologyFindings = (
 
 let checkLifecycleTopology = (
   ~pluginName: string,
-  ~writables: array<Reventless.Plugin.writableDef>,
+  ~writeSides: array<Reventless.Plugin.writeSideDef>,
   ~lifecycleStatesByView: dict<array<string>>,
 ): unit =>
-  lifecycleTopologyFindings(~writables, ~lifecycleStatesByView)->Array.forEach(((view, message)) =>
+  lifecycleTopologyFindings(~writeSides, ~lifecycleStatesByView)->Array.forEach(((view, message)) =>
     log.warn(~comp="Plugin_Structure", `${pluginName}/${view}: ${message}`)
   )
 
@@ -1074,12 +1074,12 @@ let visibilityTag = (v: Reventless.Visibility.t): option<string> =>
   }
 
 /**
- A read model's `queryableDef` assembled from its spec, for the platform's own
+ A read model's `readSideDef` assembled from its spec, for the platform's own
  components: `make` takes `module(ReadModel.T)` values, and at structure-assembly
  time the platform has no built module to hand itself. Every extractor here is the
  one `make` calls, so the two cannot drift — a hand-written record did, four times.
  */
-let queryableDefFromSpec = (
+let readSideDefFromSpec = (
   ~plugin: string,
   ~name: string,
   ~stateSchema: S.t<unknown>,
@@ -1088,7 +1088,7 @@ let queryableDefFromSpec = (
   ~consumedEventTypes: array<string>=[],
   ~linkedWriteSide: array<string>=[],
   ~chapter: option<string>=?,
-): Reventless.Plugin.queryableDef => {
+): Reventless.Plugin.readSideDef => {
   let qf = Api_Naming.queryFieldNamesForReadModel(~plugin, ~name)
   let label = labelFieldsFromStateSchema(~entityName=name, stateSchema)
   // The published key is always filterable; not every filterable field is the key.
@@ -1498,9 +1498,9 @@ let make = (
     )
   )
 
-  // ── Build queryable defs ───────────────────────────────────────────────────
+  // ── Build read-side defs ───────────────────────────────────────────────────
   //
-  // Internal views are carried here, tagged via `queryableDef.visibility`, so
+  // Internal views are carried here, tagged via `readSideDef.visibility`, so
   // developer tools see them; AutoUI's consumers re-filter on the tag.
   // View name -> the states its lifecycle field can hold, collected as the view
   // defs are built so the transition check below has both sides in one place.
@@ -1576,7 +1576,7 @@ let make = (
         idFieldSource: keyField->Option.map(((_, rung)) => rung),
         requiredAccess: accessKeysFor(R.Spec.authorization->Reventless.Authorization.named),
         requiredRoles: ?rolesFor(R.Spec.authorization->Reventless.Authorization.named),
-      }: Reventless.Plugin.queryableDef
+      }: Reventless.Plugin.readSideDef
     )
   })
 
@@ -1617,11 +1617,11 @@ let make = (
           idFieldSource: keyField->Option.map(((_, rung)) => rung),
           requiredAccess: accessKeysFor(SVS.Spec.authorization->Reventless.Authorization.named),
           requiredRoles: ?rolesFor(SVS.Spec.authorization->Reventless.Authorization.named),
-        }: Reventless.Plugin.queryableDef
+        }: Reventless.Plugin.readSideDef
       )
     })
 
-  // ── Build writable defs ────────────────────────────────────────────────────
+  // ── Build write-side defs ──────────────────────────────────────────────────
 
   // Non-throwing: this is a description of the plugin, and the builder is what
   // refuses a boundary whose partitions do not resolve.
@@ -1728,7 +1728,7 @@ let make = (
           events: extractEventDefs(~identityViews, SCS.Spec.eventSchema->S.castToUnknown),
           errors: extractErrorDefs(SCS.Spec.errorSchema->S.castToUnknown),
           chapter: chapterOf(SCS.Spec.name),
-        }: Reventless.Plugin.writableDef
+        }: Reventless.Plugin.writeSideDef
       )
     })
 
@@ -1762,7 +1762,7 @@ let make = (
         events: extractEventDefs(~identityViews, A.Spec.eventSchema->S.castToUnknown),
         errors: extractErrorDefs(A.Spec.errorSchema->S.castToUnknown),
         chapter: chapterOf(A.Spec.name),
-      }: Reventless.Plugin.writableDef
+      }: Reventless.Plugin.writeSideDef
     )
   })
 
@@ -2258,12 +2258,12 @@ let make = (
   // assembled, so the check cannot run inline where the defs are made.
   checkDeclaredTransitions(
     ~pluginName=name,
-    ~writables=Array.concat(stateChangeDefs, aggregateDefs),
+    ~writeSides=Array.concat(stateChangeDefs, aggregateDefs),
     ~lifecycleStatesByView,
   )
   checkLifecycleTopology(
     ~pluginName=name,
-    ~writables=Array.concat(stateChangeDefs, aggregateDefs),
+    ~writeSides=Array.concat(stateChangeDefs, aggregateDefs),
     ~lifecycleStatesByView,
   )
   // Also a second pass, for a different reason: the failures are gathered per

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

@@ -318,12 +318,12 @@ function extensionPartitionFailure(label, delegate, expected, actual) {
   return label + `: the extension ` + seen + `, but the plugin partitions ` + delegate + ` by ` + describePartition(expected) + `. An extension sees only the slice's command and events, not what it reads or its chapter — ` + (`add @partitionTag ` + describePartition(expected) + ` to ` + delegate + `'s event.`);
 }
 
-function checkDeclaredTransitions(pluginName, writables, lifecycleStatesByView) {
+function checkDeclaredTransitions(pluginName, writeSides, lifecycleStatesByView) {
   let unvalidated = {
     contents: 0
   };
   let failures = [];
-  writables.forEach(w => {
+  writeSides.forEach(w => {
     w.commands.forEach(cmd => {
       let t = cmd.targetState;
       let declared = Stdlib_Option.getOr(cmd.allowedStates, []).concat(t !== undefined ? [t] : []);
@@ -357,12 +357,12 @@ function checkDeclaredTransitions(pluginName, writables, lifecycleStatesByView)
   }
 }
 
-function lifecycleTopologyFindings(writables, lifecycleStatesByView) {
+function lifecycleTopologyFindings(writeSides, lifecycleStatesByView) {
   let findings = [];
   Object.entries(lifecycleStatesByView).forEach(param => {
     let states = param[1];
     let view = param[0];
-    let reachable = Stdlib_Array.reduce(writables, [], (acc, w) => {
+    let reachable = Stdlib_Array.reduce(writeSides, [], (acc, w) => {
       if (w.linkedViews.includes(view)) {
         return acc.concat(Stdlib_Array.filterMap(w.commands, cmd => cmd.targetState));
       } else {
@@ -386,8 +386,8 @@ function lifecycleTopologyFindings(writables, lifecycleStatesByView) {
   return findings;
 }
 
-function checkLifecycleTopology(pluginName, writables, lifecycleStatesByView) {
-  lifecycleTopologyFindings(writables, lifecycleStatesByView).forEach(param => log.warn("Plugin_Structure", undefined, pluginName + `/` + param[0] + `: ` + param[1]));
+function checkLifecycleTopology(pluginName, writeSides, lifecycleStatesByView) {
+  lifecycleTopologyFindings(writeSides, lifecycleStatesByView).forEach(param => log.warn("Plugin_Structure", undefined, pluginName + `/` + param[0] + `: ` + param[1]));
 }
 
 function labelFieldSourceToString(s) {
@@ -772,7 +772,7 @@ function visibilityTag(v) {
   }
 }
 
-function queryableDefFromSpec(plugin, name, stateSchema, authorization, visibilityOpt, consumedEventTypesOpt, linkedWriteSideOpt, chapter) {
+function readSideDefFromSpec(plugin, name, stateSchema, authorization, visibilityOpt, consumedEventTypesOpt, linkedWriteSideOpt, chapter) {
   let visibility = visibilityOpt !== undefined ? visibilityOpt : "Public";
   let consumedEventTypes = consumedEventTypesOpt !== undefined ? consumedEventTypesOpt : [];
   let linkedWriteSide = linkedWriteSideOpt !== undefined ? linkedWriteSideOpt : [];
@@ -1591,7 +1591,7 @@ export {
   toCommandDef,
   extractCommandDefs,
   visibilityTag,
-  queryableDefFromSpec,
+  readSideDefFromSpec,
   make,
 }
 /* log Not a pure module */

package/tests/admin/AdminApiSchemaDriftTest.res

@@ -80,7 +80,7 @@ let cmd: commandDef = {
 let evt: eventDef = {name: "ProductAdded", schema: "{}", references: [fieldRef]}
 let err: errorDef = {name: "ProductAlreadyExists", schema: "{}", references: []}
 
-let writable: writableDef = {
+let writeSide: writeSideDef = {
   name: "Product",
   commands: [cmd],
   producedEventTypes: ["ProductAdded"],
@@ -92,7 +92,7 @@ let writable: writableDef = {
   chapter: Some("Catalogue"),
 }
 
-let queryable: queryableDef = {
+let readSide: readSideDef = {
   name: "Products",
   queryField: "Catalog_Products",
   schema: "{}",
@@ -174,10 +174,10 @@ let capabilityDecl: requiredCapabilityDeclaration = {
 }
 
 let structure: pluginStructure = {
-  readModels: [queryable],
+  readModels: [readSide],
   stateViewSlices: [],
   stateChangeSlices: [],
-  aggregates: [writable],
+  aggregates: [writeSide],
   automationSlices: [automation],
   outboundTranslationSlices: [outbound],
   inboundTranslationSlices: [inbound],
@@ -278,16 +278,16 @@ let guards: array<guard> = [
   {
     gqlType: "Platform_WriteSideDef",
     sdlTypes: componentSdl,
-    recordFields: schemaKeys(writableDefSchema),
-    wireFields: jsonKeys(Platform_ComponentDefinitionsApi.encodeWritableDef(writable)),
+    recordFields: schemaKeys(writeSideDefSchema),
+    wireFields: jsonKeys(Platform_ComponentDefinitionsApi.encodeWriteSideDef(writeSide)),
     wireOnly: [],
     recordOnly: [],
   },
   {
     gqlType: "Platform_ReadSideDef",
     sdlTypes: componentSdl,
-    recordFields: schemaKeys(queryableDefSchema),
-    wireFields: jsonKeys(Platform_ComponentDefinitionsApi.encodeQueryableDef(queryable)),
+    recordFields: schemaKeys(readSideDefSchema),
+    wireFields: jsonKeys(Platform_ComponentDefinitionsApi.encodeReadSideDef(readSide)),
     wireOnly: [],
     // The roles behind `requiredAccess`, read by the deploy check in-process.
     // A client gates on the mapped groups and has no use for role names.

package/tests/admin/AdminApiSchemaDriftTest.res.mjs

@@ -100,82 +100,82 @@ let err = {
   references: err_references
 };
 
-let writable_commands = [cmd];
+let writeSide_commands = [cmd];
 
-let writable_producedEventTypes = ["ProductAdded"];
+let writeSide_producedEventTypes = ["ProductAdded"];
 
-let writable_consumedEventTypes = [];
+let writeSide_consumedEventTypes = [];
 
-let writable_linkedViews = ["Products"];
+let writeSide_linkedViews = ["Products"];
 
-let writable_consistencyRead = "Products";
+let writeSide_consistencyRead = "Products";
 
-let writable_events = [evt];
+let writeSide_events = [evt];
 
-let writable_errors = [err];
+let writeSide_errors = [err];
 
-let writable_chapter = "Catalogue";
+let writeSide_chapter = "Catalogue";
 
-let writable = {
+let writeSide = {
   name: "Product",
-  commands: writable_commands,
-  producedEventTypes: writable_producedEventTypes,
-  consumedEventTypes: writable_consumedEventTypes,
-  linkedViews: writable_linkedViews,
-  consistencyRead: writable_consistencyRead,
-  events: writable_events,
-  errors: writable_errors,
-  chapter: writable_chapter
+  commands: writeSide_commands,
+  producedEventTypes: writeSide_producedEventTypes,
+  consumedEventTypes: writeSide_consumedEventTypes,
+  linkedViews: writeSide_linkedViews,
+  consistencyRead: writeSide_consistencyRead,
+  events: writeSide_events,
+  errors: writeSide_errors,
+  chapter: writeSide_chapter
 };
 
-let queryable_consumedEventTypes = ["ProductAdded"];
+let readSide_consumedEventTypes = ["ProductAdded"];
 
-let queryable_linkedWriteSide = ["Product"];
+let readSide_linkedWriteSide = ["Product"];
 
-let queryable_searchableFields = ["displayName"];
+let readSide_searchableFields = ["displayName"];
 
-let queryable_labelFieldSource = "annotation";
+let readSide_labelFieldSource = "annotation";
 
-let queryable_lifecycleField = "lifecycle";
+let readSide_lifecycleField = "lifecycle";
 
-let queryable_ownerField = "ownerId";
+let readSide_ownerField = "ownerId";
 
-let queryable_retiredField = "archived";
+let readSide_retiredField = "archived";
 
-let queryable_retiredValues = ["Archived"];
+let readSide_retiredValues = ["Archived"];
 
-let queryable_namedWhenRetired = true;
+let readSide_namedWhenRetired = true;
 
-let queryable_chapter = "Catalogue";
+let readSide_chapter = "Catalogue";
 
-let queryable_singleQueryField = "Catalog_Product";
+let readSide_singleQueryField = "Catalog_Product";
 
-let queryable_idField = "productId";
+let readSide_idField = "productId";
 
-let queryable_idFieldSource = "convention";
+let readSide_idFieldSource = "convention";
 
-let queryable_requiredAccess = ["catalog.read"];
+let readSide_requiredAccess = ["catalog.read"];
 
-let queryable = {
+let readSide = {
   name: "Products",
   queryField: "Catalog_Products",
   schema: "{}",
-  consumedEventTypes: queryable_consumedEventTypes,
-  linkedWriteSide: queryable_linkedWriteSide,
+  consumedEventTypes: readSide_consumedEventTypes,
+  linkedWriteSide: readSide_linkedWriteSide,
   labelField: "displayName",
-  searchableFields: queryable_searchableFields,
-  labelFieldSource: queryable_labelFieldSource,
-  lifecycleField: queryable_lifecycleField,
-  ownerField: queryable_ownerField,
-  retiredField: queryable_retiredField,
-  retiredValues: queryable_retiredValues,
-  namedWhenRetired: queryable_namedWhenRetired,
+  searchableFields: readSide_searchableFields,
+  labelFieldSource: readSide_labelFieldSource,
+  lifecycleField: readSide_lifecycleField,
+  ownerField: readSide_ownerField,
+  retiredField: readSide_retiredField,
+  retiredValues: readSide_retiredValues,
+  namedWhenRetired: readSide_namedWhenRetired,
   visibility: undefined,
-  chapter: queryable_chapter,
-  singleQueryField: queryable_singleQueryField,
-  idField: queryable_idField,
-  idFieldSource: queryable_idFieldSource,
-  requiredAccess: queryable_requiredAccess
+  chapter: readSide_chapter,
+  singleQueryField: readSide_singleQueryField,
+  idField: readSide_idField,
+  idFieldSource: readSide_idFieldSource,
+  requiredAccess: readSide_requiredAccess
 };
 
 let automation_consumedEventTypes = ["StockLow"];
@@ -293,13 +293,13 @@ let capabilityDecl = {
   component: "GeocodeAddress"
 };
 
-let structure_readModels = [queryable];
+let structure_readModels = [readSide];
 
 let structure_stateViewSlices = [];
 
 let structure_stateChangeSlices = [];
 
-let structure_aggregates = [writable];
+let structure_aggregates = [writeSide];
 
 let structure_automationSlices = [automation];
 
@@ -414,16 +414,16 @@ let guards = [
   {
     gqlType: "Platform_WriteSideDef",
     sdlTypes: Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes,
-    recordFields: schemaKeys(Plugin$Reventless.writableDefSchema),
-    wireFields: jsonKeys(Platform_ComponentDefinitionsApi$ReventlessCore.encodeWritableDef(writable)),
+    recordFields: schemaKeys(Plugin$Reventless.writeSideDefSchema),
+    wireFields: jsonKeys(Platform_ComponentDefinitionsApi$ReventlessCore.encodeWriteSideDef(writeSide)),
     wireOnly: [],
     recordOnly: []
   },
   {
     gqlType: "Platform_ReadSideDef",
     sdlTypes: Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes,
-    recordFields: schemaKeys(Plugin$Reventless.queryableDefSchema),
-    wireFields: jsonKeys(Platform_ComponentDefinitionsApi$ReventlessCore.encodeQueryableDef(queryable)),
+    recordFields: schemaKeys(Plugin$Reventless.readSideDefSchema),
+    wireFields: jsonKeys(Platform_ComponentDefinitionsApi$ReventlessCore.encodeReadSideDef(readSide)),
     wireOnly: [],
     recordOnly: ["requiredRoles"]
   },
@@ -604,8 +604,8 @@ export {
   cmd,
   evt,
   err,
-  writable,
-  queryable,
+  writeSide,
+  readSide,
   automation,
   outbound,
   inbound,