@reventlessdev/reventless-core 3.0.0-alpha.199 → 3.0.0-alpha.201

package/CHANGELOG.md

@@ -3,6 +3,37 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.201 (2026-08-02)
+
+### Features
+
+* **aws,core,doc:** environment-tiered CloudWatch log retention and levels ([8032023](https://github.com/ReventlessDev/reventless-core/commit/803202305a7d352484b8df5e58df03c92ca58b5f))
+* **aws,core,spec,seed-aws:** expire uploads nobody committed a reference to ([f63e84c](https://github.com/ReventlessDev/reventless-core/commit/f63e84c1a11cc350b799a6f69a2e7427cf1ea6e9))
+
+
+# 3.0.0-alpha.200 (2026-08-01)
+
+* feat(aws,core,spec)!: qualify store prefixes by plugin and refuse name collisions ([da39405](https://github.com/ReventlessDev/reventless-core/commit/da394059d9f8f981bf7adc79e2c1ce2b429e0267))
+* feat(core,aws)!: name task buckets for their plugin and task ([05203cb](https://github.com/ReventlessDev/reventless-core/commit/05203cb3b0b019401a6f32cf78109f397b6799d5))
+### Features
+
+* **spec:** a coordinate is one declared point, not two fields and a name guess ([bfe2f90](https://github.com/ReventlessDev/reventless-core/commit/bfe2f90241492422d6c242e3f50e31b81ed2a010))
+
+### BREAKING CHANGES
+
+* objects minted under the old bare prefix are orphaned and their
+refs unresolvable. The migration is `seed:reset` for the owning plugin, then
+re-seed. Legacy-prefix grandfathering was considered and deliberately dropped —
+it would have added a permanent prefix SET across the deploy argument, both store
+configs, the presign IAM fan-out, the release scope check and the stack output,
+to spare a disposable stack one wipe.
+* a bucket name change is a replace. TaskBucket_S3 now sets
+forceDestroy on disposable stacks (Util_StoreLayout.protectionFor), so pr-*
+stacks recreate cleanly; protected stacks must have the task bucket drained by
+hand before the first deploy after this, or the replace fails BucketNotEmpty.
+
+
+
 # 3.0.0-alpha.199 (2026-08-01)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.199",
+  "version": "3.0.0-alpha.201",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,22 +28,22 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-node": "2.0.0-alpha.0",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.0",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.0",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.118",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.116",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.91",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.30"
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.93"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.59"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.60"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/adapter/Runtime/Runtime.res

@@ -200,6 +200,11 @@ type commandHandlerConfig = {
   sqsBatchSize?: int,
   ephemeralStorageMb?: int,
   logRetentionDays?: int,
+  // Minimum log level for this handler ("silent" | "error" | "warn" | "info" |
+  // "debug"), mapped onto the `LOG_LEVEL` env var the logger reads. Overrides the
+  // per-environment tier default. Transport-neutral: the in-memory platform reads
+  // it the same way via the env var.
+  logLevel?: string,
   envVars?: dict<string>,
 }
 
@@ -220,5 +225,8 @@ module CommandHandlerDefaults = {
   let timeout = 30
   let sqsBatchSize = 10
   let ephemeralStorageMb = 512
-  let logRetentionDays = 7
+  // No `logRetentionDays` / `logLevel` default here: both are resolved per
+  // environment tier by the AWS platform (`Util_LogRetention`), not by a flat
+  // framework constant. An unset field means "follow the stack's tier", which a
+  // single number could not express.
 }

package/src/adapter/Runtime/Runtime.res.mjs

@@ -48,8 +48,7 @@ let CommandHandlerDefaults = {
   memorySize: 1024,
   timeout: 30,
   sqsBatchSize: 10,
-  ephemeralStorageMb: 512,
-  logRetentionDays: 7
+  ephemeralStorageMb: 512
 };
 
 export {

package/src/admin/Platform_Admin.res

@@ -309,7 +309,7 @@ module Make = (
       })
     let eventLogEntries = Array.concat(eventLogEntriesFromAggregates, dcbResult.eventLogEntries)
     Config.hooks.subscriptionInfraHook->Option.forEach(hook =>
-      hook({allQueryDbs, allEventTopics, eventLogEntries, opts})
+      hook({pluginName: name, allQueryDbs, allEventTopics, eventLogEntries, opts})
     )
 
     let queryEngine = QueryEngineAdapter.make(allQueryDbs)

package/src/admin/Platform_Admin.res.mjs

@@ -150,6 +150,7 @@ function Make(RuntimeEnvironment) {
       }));
       let eventLogEntries = eventLogEntriesFromAggregates.concat(dcbResult.eventLogEntries);
       Stdlib_Option.forEach(Config.hooks.subscriptionInfraHook, hook => hook({
+        pluginName: Platform_Admin_Structure$ReventlessCore.pluginId,
         allQueryDbs: allQueryDbs,
         allEventTopics: aggregateEventTopics,
         eventLogEntries: eventLogEntries,

package/src/admin/Platform_AdminApi.res

@@ -89,7 +89,7 @@ let pluginStatusSubscriptionSource: GraphQL_Stitcher.subscriptionSource = {
 // (`injectAwsAuthAll(~group="Admin")`), and uploads are a regular authenticated-user
 // operation. They are added instead to the **domain** API's platform-owned base
 // (`domainBaseFragment` in the AWS/local Platform), which takes the default
-// `AllowAuthenticated` auth. See [docs/plans/upload-release-path.md] § "Which API".
+// `AllowAuthenticated` auth. See [docs/plans/done/upload-release-path.md] § "Which API".
 let uploadTypes = [
   `type Upload_Ticket {\n  uploadUrl: String!\n  storageRef: String!\n}`,
   `type Upload_ReleaseResult {\n  released: Boolean!\n  reason: String\n}`,

package/src/components/Api/StorageRefFields.res

@@ -0,0 +1,124 @@
+// Which fields of which committed events can hold a storage ref — read off the
+// declarations rather than hand-listed.
+//
+// This is the deploy-time half of the claim mechanism (see
+// [docs/plans/done/upload-pending-claim-and-expiry.md]). An uploaded object is minted
+// carrying a "pending" tag and expires while it still has one, so something has
+// to notice when an event finally references it. That something needs to know
+// three things, and a `@storageRef` declaration already says all three:
+//
+//   which events to observe   only variants with at least one declared field
+//   where the refs sit        the field name, and whether it holds one or many
+//   which store they're in    the target, qualified to `{plugin}.{store}`
+//
+// Deriving it here rather than in the claimer means the runtime carries a flat
+// lookup table and no schema machinery: the Lambda reads `{eventType → fields}`
+// and never sees a sury schema. It also means an annotation added, moved or
+// deleted changes what gets claimed on the next deploy, with nothing to keep in
+// sync by hand.
+//
+// Read the same way `Plugin_Structure` reads the same declarations — top-level
+// properties of each variant, via `StorageRef.getFieldStore`. A store nested
+// inside an object is not provisioned there and so is not claimed here: one
+// reading, consistently narrow, rather than two that could disagree about which
+// fields exist.
+
+/** One declared ref-bearing field of one event variant. */
+type refField = {
+  /** The field's name on the event's payload (`data` on the wire). */
+  field: string,
+  /** Whether the field holds one ref or an array of them. */
+  arity: Reventless.StorageRef.arity,
+  /** The store the refs live in, qualified `{plugin}.{store}` — already
+      resolved against the declaring plugin, so a reader never has to know
+      whose plugin it came from. */
+  store: string,
+}
+
+/** The ref-bearing fields of one event variant. Only variants with at least
+    one are produced, so an empty result means "this event log carries no
+    storage refs" and the caller can skip it entirely. */
+type eventRefFields = {
+  eventType: string,
+  fields: array<refField>,
+}
+
+// A variant is `{TAG: "<Name>", …fields}` (payload-less variants are a bare
+// string const and can hold nothing, so they drop out here).
+let fromVariant = (~plugin: string, variant: S.t<unknown>): option<eventRefFields> =>
+  switch variant {
+  | S.Object({properties}) =>
+    switch properties->Dict.get("TAG") {
+    | Some(String({const: ?Some(eventType)})) =>
+      let fields =
+        properties
+        ->Dict.toArray
+        ->Array.filterMap(((field, fieldSchema)) =>
+          Reventless.StorageRef.getFieldStore(fieldSchema)->Option.map(((target, arity)) => {
+            field,
+            arity,
+            // An unqualified store belongs to the declaring plugin — the same
+            // resolution `Plugin_Structure` makes, so the key the claimer looks
+            // up is the key the deploy provisioned.
+            store: target.plugin->Option.getOr(plugin) ++ "." ++ target.store,
+          })
+        )
+        ->Array.toSorted((a, b) => String.compare(a.field, b.field))
+      fields->Array.length == 0 ? None : Some({eventType, fields})
+    | _ => None
+    }
+  | _ => None
+  }
+
+/**
+The ref-bearing fields of every variant in an event log's event schema.
+
+`~plugin` is the registered name of the plugin the event log belongs to, used
+to qualify a store the annotation left unqualified.
+*/
+let fromEventSchema = (~plugin: string, eventSchema: S.t<unknown>): array<eventRefFields> =>
+  switch eventSchema {
+  | Union({anyOf}) => anyOf->Array.filterMap(v => fromVariant(~plugin, v))
+  | other => fromVariant(~plugin, other)->Option.mapOr([], e => [e])
+  }
+
+/**
+The wire form the claimer reads: `{"<eventType>": [{"field", "arity", "store"}]}`.
+
+A flat JSON object rather than a schema, because it crosses into a Lambda's
+environment: the runtime side does a dictionary lookup and a field read, and
+carries no sury dependency to do it.
+*/
+let toJson = (entries: array<eventRefFields>): JSON.t =>
+  entries
+  ->Array.map(({eventType, fields}) => (
+    eventType,
+    fields
+    ->Array.map(({field, arity, store}) =>
+      Dict.fromArray([
+        ("field", JSON.Encode.string(field)),
+        (
+          "arity",
+          JSON.Encode.string(
+            switch arity {
+            | Single => "one"
+            | Multiple => "many"
+            },
+          ),
+        ),
+        ("store", JSON.Encode.string(store)),
+      ])->JSON.Encode.object
+    )
+    ->JSON.Encode.array,
+  ))
+  ->Dict.fromArray
+  ->JSON.Encode.object
+
+/** The distinct stores an event log's declarations point at. What the claimer's
+    IAM has to cover for that log, and what a coverage check compares against
+    the set of stores the deploy actually provisioned. */
+let storesOf = (entries: array<eventRefFields>): array<string> =>
+  entries
+  ->Array.flatMap(({fields}) => fields->Array.map(({store}) => store))
+  ->Belt.Set.String.fromArray
+  ->Belt.Set.String.toArray

package/src/components/Api/StorageRefFields.res.mjs

@@ -0,0 +1,88 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
+
+function fromVariant(plugin, variant) {
+  if (variant.type !== "object") {
+    return;
+  }
+  let properties = variant.properties;
+  let match = properties["TAG"];
+  if (match === undefined) {
+    return;
+  }
+  if (match.type !== "string") {
+    return;
+  }
+  let eventType = match.const;
+  if (eventType === undefined) {
+    return;
+  }
+  let fields = Stdlib_Array.filterMap(Object.entries(properties), param => {
+    let field = param[0];
+    return Stdlib_Option.map(StorageRef$Reventless.getFieldStore(param[1]), param => {
+      let target = param[0];
+      return {
+        field: field,
+        arity: param[1],
+        store: Stdlib_Option.getOr(target.plugin, plugin) + "." + target.store
+      };
+    });
+  }).toSorted((a, b) => Primitive_string.compare(a.field, b.field));
+  if (fields.length === 0) {
+    return;
+  } else {
+    return {
+      eventType: eventType,
+      fields: fields
+    };
+  }
+}
+
+function fromEventSchema(plugin, eventSchema) {
+  if (eventSchema.type === "union") {
+    return Stdlib_Array.filterMap(eventSchema.anyOf, v => fromVariant(plugin, v));
+  } else {
+    return Stdlib_Option.mapOr(fromVariant(plugin, eventSchema), [], e => [e]);
+  }
+}
+
+function toJson(entries) {
+  return Object.fromEntries(entries.map(param => [
+    param.eventType,
+    param.fields.map(param => {
+      let tmp;
+      tmp = param.arity === "Single" ? "one" : "many";
+      return Object.fromEntries([
+        [
+          "field",
+          param.field
+        ],
+        [
+          "arity",
+          tmp
+        ],
+        [
+          "store",
+          param.store
+        ]
+      ]);
+    })
+  ]));
+}
+
+function storesOf(entries) {
+  return Belt_SetString.toArray(Belt_SetString.fromArray(entries.flatMap(param => param.fields.map(param => param.store))));
+}
+
+export {
+  fromVariant,
+  fromEventSchema,
+  toJson,
+  storesOf,
+}
+/* StorageRef-Reventless Not a pure module */

package/src/components/Task/Task_Builder.res

@@ -14,6 +14,71 @@ let pascalCase = s =>
   )
   ->Array.join("")
 
+// Split words out of a PascalCase/camelCase run so kebab-casing keeps the word
+// boundaries. Two passes: `aB` splits an ordinary hump, `ABc` splits the tail of
+// an acronym off the word that follows it ("HTTPServer" -> "HTTP-Server").
+let humpBoundary = %re("/([a-z0-9])([A-Z])/g")
+let acronymBoundary = %re("/([A-Z]+)([A-Z][a-z])/g")
+
+// Kebab-case an identifier for use in an S3 bucket name: "ImportProducts" and
+// "product-imports" both reduce to "import-products".
+//
+// S3 lowercases bucket names, so a PascalCase segment collapses into an
+// unreadable run-on ("importproductsproductimportsbucket"). Kebab survives the
+// lowercasing with its word boundaries intact, which is why the framework's
+// declared-store buckets (`Util_StoreLayout.bucketNameFor`) already use it.
+let kebabCase = s =>
+  s
+  ->String.replaceRegExp(acronymBoundary, "$1-$2")
+  ->String.replaceRegExp(humpBoundary, "$1-$2")
+  ->String.split("-")
+  ->Array.flatMap(p => p->String.split("_"))
+  ->Array.filter(p => p->String.length > 0)
+  ->Array.map(String.toLowerCase)
+  ->Array.join("-")
+
+// S3 caps a bucket name at 63 characters and Pulumi appends `-` plus a 7-char
+// uniqueness suffix, so the composed name has 55 to work with.
+let maxBucketNameLength = 55
+
+/**
+The Pulumi resource name for a task's bucket: `{plugin}-{task}` for a task's
+default bucket, `{plugin}-{task}-{bucketId}` when the declaration names one.
+
+`plugin` is the ambient plugin under construction, absent for a task built
+outside any plugin. No `Bucket` suffix — `aws:s3/bucket` and the
+`reventless:role=Bucket` tag both already say what it is.
+
+Composed rather than sanitised, so a name too long for S3 is the caller's to fix:
+truncating here would silently manufacture a collision between two long names
+that share a prefix.
+*/
+let bucketResourceName = (
+  ~plugin: option<string>,
+  ~task: string,
+  ~bucketId: option<string>,
+): string => {
+  let name =
+    [plugin, Some(task), bucketId]
+    ->Array.filterMap(segment => segment)
+    ->Array.map(kebabCase)
+    ->Array.filter(segment => segment != "")
+    ->Array.join("-")
+  if name->String.length > maxBucketNameLength {
+    JsError.throwWithMessage(
+      `Task bucket name "${name}" is ${name
+        ->String.length
+        ->Int.toString} characters; S3 allows ${maxBucketNameLength->Int.toString} once Pulumi's ` ++
+      `uniqueness suffix is added. Shorten the task name` ++
+      switch bucketId {
+      | Some(id) => ` or the bucket id "${id}".`
+      | None => "."
+      },
+    )
+  }
+  name
+}
+
 module Make = (
   Spec: Task.Spec,
   RuntimeEnvironment: Runtime.Environment,
@@ -169,11 +234,17 @@ module Make = (
       buckets
       ->Array.map(bucketSpec => {
         let bucketName = bucketSpec.bucketName->Option.getOr("Bucket")
-        // `bucketStem` is the PascalCase resource-name segment (empty for the
-        // default unnamed bucket so the name stays `<Task>Bucket`, not
-        // `<Task>BucketBucket`). `bucketName` above remains the runtime key.
+        // `bucketStem` is the PascalCase segment naming this bucket's Lambda
+        // (empty for the default unnamed bucket). `bucketName` above remains the
+        // runtime key into `Task.bucketNames`; `name` is the bucket's own
+        // resource name, kebab-cased and plugin-qualified because S3 lowercases
+        // it — see `bucketResourceName`.
         let bucketStem = bucketSpec.bucketName->Option.mapOr("", pascalCase)
-        let name = taskName ++ bucketStem ++ "Bucket"
+        let name = bucketResourceName(
+          ~plugin=ResourceAttribution.current.contents.plugin,
+          ~task=taskName,
+          ~bucketId=bucketSpec.bucketName,
+        )
         let bucket = TaskBucket.make(~name, ~opts)
         let opts = {Pulumi.ComponentResource.parent: bucket.parts->Pulumi.Resource.makeFromJs}
 

package/src/components/Task/Task_Builder.res.mjs

@@ -1,9 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Task$ReventlessCore from "./Task.res.mjs";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
@@ -13,6 +15,7 @@ import * as Util_Promise$ReventlessCore from "../../util/Util_Promise.res.mjs";
 import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
 import * as RuntimeHints$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/RuntimeHints.res.mjs";
 import * as Builder_Helpers$ReventlessCore from "../Builder_Helpers.res.mjs";
+import * as ResourceAttribution$ReventlessCore from "../../ResourceAttribution.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
 
@@ -20,6 +23,28 @@ function pascalCase(s) {
   return s.split("-").flatMap(p => p.split("_")).filter(p => p.length > 0).map(p => p.slice(0, 1).toUpperCase() + p.slice(1, p.length)).join("");
 }
 
+let humpBoundary = /([a-z0-9])([A-Z])/g;
+
+let acronymBoundary = /([A-Z]+)([A-Z][a-z])/g;
+
+function kebabCase(s) {
+  return s.replace(acronymBoundary, "$1-$2").replace(humpBoundary, "$1-$2").split("-").flatMap(p => p.split("_")).filter(p => p.length > 0).map(prim => prim.toLowerCase()).join("-");
+}
+
+function bucketResourceName(plugin, task, bucketId) {
+  let name = Stdlib_Array.filterMap([
+    plugin,
+    task,
+    bucketId
+  ], segment => segment).map(kebabCase).filter(segment => segment !== "").join("-");
+  if (name.length > 55) {
+    Stdlib_JsError.throwWithMessage(`Task bucket name "` + name + `" is ` + name.length.toString() + ` characters; S3 allows ` + (55).toString() + ` once Pulumi's uniqueness suffix is added. Shorten the task name` + (
+      bucketId !== undefined ? ` or the bucket id "` + bucketId + `".` : "."
+    ));
+  }
+  return name;
+}
+
 function Make(Spec) {
   return RuntimeEnvironment => (EventCollectorChannel => (EventCollectorRuntimeBuilder => (TaskRuntimeBuilder => (TaskBucket => (SpecificSideEffectHandler => (Defaults => {
     let make = (queryBucketName, scheduler, schedulerRoleUrn, publishToAggregates, queryEngine, resourceNaming, allAggregates, runtime, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(Task$ReventlessCore.componentType), Spec.name, (extra, extra$1) => {
@@ -85,7 +110,7 @@ function Make(Spec) {
       let bucketNames = Stdlib_Option.map(config.buckets, buckets => Object.fromEntries(buckets.map(bucketSpec => {
         let bucketName = Stdlib_Option.getOr(bucketSpec.bucketName, "Bucket");
         let bucketStem = Stdlib_Option.mapOr(bucketSpec.bucketName, "", pascalCase);
-        let name = extra$1 + bucketStem + "Bucket";
+        let name = bucketResourceName(ResourceAttribution$ReventlessCore.current.contents.plugin, extra$1, bucketSpec.bucketName);
         let bucket = TaskBucket.make(name, opts);
         let opts_parent = bucket.parts;
         let opts$1 = {
@@ -112,9 +137,16 @@ function Make(Spec) {
   }))))));
 }
 
+let maxBucketNameLength = 55;
+
 export {
   log,
   pascalCase,
+  humpBoundary,
+  acronymBoundary,
+  kebabCase,
+  maxBucketNameLength,
+  bucketResourceName,
   Make,
 }
 /* log Not a pure module */

package/src/plugin/component/Plugin_Builder.res

@@ -888,7 +888,7 @@ module Make = (
         // Gives the AWS platform access to allQueryDbs, allEventTopics, and eventLogEntries
         // without coupling reventless-core to reventless-aws.
         Spec.hooks.subscriptionInfraHook->Option.forEach(hook =>
-          hook({allQueryDbs, allEventTopics, eventLogEntries, opts})
+          hook({pluginName: name, allQueryDbs, allEventTopics, eventLogEntries, opts})
         )
 
         module SpecificHeartbeat = Heartbeat_Builder.Make(HeartbeatRunner)

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

@@ -547,6 +547,7 @@ function Make(Spec) {
           let tasksOutputs = Plugin_Helpers$ReventlessCore.createTasks(tasks, aggregatesOutputs, scheduler, schedulerRoleUrn, publishToAggregates, queryEngine, Spec.resourceNaming, componentRuntime, opts);
           let resolvers = Plugin_Helpers$ReventlessCore.createResolvers(allQueryDbs);
           Stdlib_Option.forEach(Spec.hooks.subscriptionInfraHook, hook => hook({
+            pluginName: extra$1,
             allQueryDbs: allQueryDbs,
             allEventTopics: aggregateEventTopics,
             eventLogEntries: eventLogEntries,

package/src/plugin/component/Plugin_Helpers.res

@@ -911,6 +911,11 @@ type eventQueryRegistrationParams = {
 // are assembled inside builderOutputs.  Lets the AWS platform wire StateTopic and
 // EventLogSubscription Lambdas without touching reventless-core.
 type subscriptionInfraParams = {
+  /** The plugin's registered name. Carried because infrastructure wired from
+      here can be per plugin rather than per component — and because a
+      declaration that names a store without qualifying it means "this plugin's
+      own", which is unreadable without knowing whose plugin it is. */
+  pluginName: string,
   allQueryDbs: ReventlessInfra.QueryDb.allOutputs,
   allEventTopics: dict<ReventlessInfra.EventTopic.outputs>,
   eventLogEntries: array<ReventlessInfra.Api.eventLogSchemaEntry>,

package/src/plugin/component/Plugin_Structure.res

@@ -503,7 +503,11 @@ let make = (
     properties
     ->Dict.toArray
     ->Array.filterMap(((field, fieldSchema)) =>
-      Reventless.StorageRef.getStore(fieldSchema)->Option.map(target => {
+      // `getFieldStore`, not `getStore`: a `@storageRef("s") urls: array<string>`
+      // field carries the marker on its *element*, so reading the field schema
+      // directly answered `None` and the store went unprovisioned — the same
+      // silence as never having written the annotation.
+      Reventless.StorageRef.getFieldStore(fieldSchema)->Option.map(((target, _arity)) => {
         Reventless.Plugin.store: target.plugin->Option.getOr(name) ++ "." ++ target.store,
         component,
         field,

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

@@ -446,7 +446,8 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
         let properties = v.properties;
         return Stdlib_Array.filterMap(Object.entries(properties), param => {
           let field = param[0];
-          return Stdlib_Option.map(StorageRef$Reventless.getStore(param[1]), target => {
+          return Stdlib_Option.map(StorageRef$Reventless.getFieldStore(param[1]), param => {
+            let target = param[0];
             let plugin = target.plugin;
             return {
               store: Stdlib_Option.getOr(target.plugin, name) + "." + target.store,