@reventlessdev/reventless-core 3.0.0-alpha.239 → 3.0.0-alpha.241

package/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Uuid from "uuid";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
@@ -10,20 +11,18 @@ import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_excep
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
 
-S.enableJson();
-
-let auditStatusSchema = S.union([
-  S.literal("Success"),
-  S.literal("Failure")
+let auditStatusSchema = Sury.union([
+  Sury.literal("Success"),
+  Sury.literal("Failure")
 ]);
 
-let auditRowSchema = S.schema(s => ({
-  input: s.m(S.string),
+let auditRowSchema = Sury.$schema(s => ({
+  input: s.m(Sury.string),
   status: s.m(auditStatusSchema),
-  targetIds: s.m(S.option(S.array(S.string))),
-  commandCount: s.m(S.option(S.int)),
-  error: s.m(S.option(S.string)),
-  receivedAt: s.m(S.string)
+  targetIds: s.m(Sury.$option(Sury.array(Sury.string))),
+  commandCount: s.m(Sury.$option(Sury.int)),
+  error: s.m(Sury.$option(Sury.string)),
+  receivedAt: s.m(Sury.string)
 }));
 
 function receiveResultToOutcome(result) {
@@ -236,4 +235,4 @@ export {
   takeAuditRow,
   Make,
 }
-/*  Not a pure module */
+/* auditStatusSchema Not a pure module */

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res

@@ -1,4 +1,3 @@
-S.enableJson()
 // OutboundTranslationSlice callback — implements the tracked external call pattern.
 //
 // Phase 1 (collect): updates the in-memory TODO list from events (no resolve)
@@ -144,7 +143,7 @@ module Make = (
         | Some(_) => () // Already exists -- skip (idempotent)
         | None =>
           let row: todoRow = {
-            item: item->S.reverseConvertToJsonOrThrow(Spec.outboundItemSchema),
+            item: item->Reventless.Util_Sury.toJson(Spec.outboundItemSchema),
             status: Pending,
             createdAt: now(),
             retryCount: 0,
@@ -170,7 +169,7 @@ module Make = (
     let _ = await pending->Array.reduce(Promise.resolve(), async (prev, (id, row)) => {
       let _ = await prev
 
-      let item = try row.item->S.parseJsonOrThrow(Spec.outboundItemSchema)->Some catch {
+      let item = try row.item->Reventless.Util_Sury.fromJson(Spec.outboundItemSchema)->Some catch {
       | exn =>
         let errMsg =
           exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
@@ -200,7 +199,7 @@ module Make = (
         | Ok(Some((targetId, cmd))) =>
           // Encode command and publish
           let commandJson = try cmd
-          ->S.reverseConvertToJsonOrThrow(Spec.inboundCommandSchema)
+          ->Reventless.Util_Sury.toJson(Spec.inboundCommandSchema)
           ->Some catch {
           | exn =>
             let errMsg =

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs

@@ -1,43 +1,42 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
 
-S.enableJson();
-
-let todoStatusSchema = S.union([
-  S.literal("Pending"),
-  S.literal("Processing"),
-  S.literal("Completed"),
-  S.literal("Failed")
+let todoStatusSchema = Sury.union([
+  Sury.literal("Pending"),
+  Sury.literal("Processing"),
+  Sury.literal("Completed"),
+  Sury.literal("Failed")
 ]);
 
-let todoRowSchema = S.schema(s => ({
-  item: s.m(S.json),
+let todoRowSchema = Sury.$schema(s => ({
+  item: s.m(Sury.json),
   status: s.m(todoStatusSchema),
-  createdAt: s.m(S.string),
-  processedAt: s.m(S.option(S.string)),
-  completedAt: s.m(S.option(S.string)),
-  retryCount: s.m(S.int),
-  lastError: s.m(S.option(S.string))
+  createdAt: s.m(Sury.string),
+  processedAt: s.m(Sury.$option(Sury.string)),
+  completedAt: s.m(Sury.$option(Sury.string)),
+  retryCount: s.m(Sury.int),
+  lastError: s.m(Sury.$option(Sury.string))
 }));
 
 function todoRowSchemaFor(itemSchema) {
-  return S.schema(s => ({
+  return Sury.$schema(s => ({
     item: s.m(itemSchema),
     status: s.m(todoStatusSchema),
-    createdAt: s.m(S.string),
-    processedAt: s.m(S.option(S.string)),
-    completedAt: s.m(S.option(S.string)),
-    retryCount: s.m(S.int),
-    lastError: s.m(S.option(S.string))
+    createdAt: s.m(Sury.string),
+    processedAt: s.m(Sury.$option(Sury.string)),
+    completedAt: s.m(Sury.$option(Sury.string)),
+    retryCount: s.m(Sury.int),
+    lastError: s.m(Sury.$option(Sury.string))
   }));
 }
 
@@ -53,7 +52,7 @@ function Make(Spec) {
           if (match !== undefined) {
             return;
           }
-          let row_item = S.reverseConvertToJsonOrThrow(param[1], Spec.outboundItemSchema);
+          let row_item = Util_Sury$Reventless.toJson(param[1], Spec.outboundItemSchema);
           let row_createdAt = new Date().toISOString();
           let row = {
             item: row_item,
@@ -82,7 +81,7 @@ function Make(Spec) {
         await prev;
         let item;
         try {
-          item = Primitive_option.some(S.parseJsonOrThrow(row.item, Spec.outboundItemSchema));
+          item = Primitive_option.some(Util_Sury$Reventless.fromJson(row.item, Spec.outboundItemSchema));
         } catch (raw_exn) {
           let exn = Primitive_exceptions.internalToException(raw_exn);
           let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown");
@@ -112,7 +111,7 @@ function Make(Spec) {
           if (match !== undefined) {
             let commandJson;
             try {
-              commandJson = S.reverseConvertToJsonOrThrow(match[1], Spec.inboundCommandSchema);
+              commandJson = Util_Sury$Reventless.toJson(match[1], Spec.inboundCommandSchema);
             } catch (raw_exn$2) {
               let exn$2 = Primitive_exceptions.internalToException(raw_exn$2);
               let errMsg$1 = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn$2), Stdlib_JsExn.message), "unknown");
@@ -183,4 +182,4 @@ export {
   todoRowSchemaFor,
   Make,
 }
-/*  Not a pure module */
+/* todoStatusSchema Not a pure module */

package/src/components/SideEffectHandler/SideEffectHandler_Callback.res

@@ -25,7 +25,7 @@ module Make = (Spec: Spec): T => {
     ->JSON.Decode.object
     ->Option.flatMap(eventObj' => {
       let metaJson = eventObj'->Dict.get("meta")
-      switch metaJson->Option.map(meta => meta->S.parseJsonOrThrow(Message.metaSchema)) {
+      switch metaJson->Option.map(meta => meta->Reventless.Util_Sury.fromJson(Message.metaSchema)) {
       | Some(eventMeta) =>
         let entry =
           sideEffectsWithTags->Array.find(((module(SideEffect: Reventless.SideEffect.T), _)) =>

package/src/components/SideEffectHandler/SideEffectHandler_Callback.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
 import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
@@ -10,6 +9,7 @@ import * as Stream from "effect/Stream";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
 import * as Util_Error$ReventlessCore from "../../util/Util_Error.res.mjs";
@@ -24,7 +24,7 @@ function Make(Spec) {
     let metaJson = eventObj$p["meta"];
     let eventMeta;
     try {
-      eventMeta = Stdlib_Option.map(metaJson, meta => S.parseJsonOrThrow(meta, Message$ReventlessCore.metaSchema));
+      eventMeta = Stdlib_Option.map(metaJson, meta => Util_Sury$Reventless.fromJson(meta, Message$ReventlessCore.metaSchema));
     } catch (raw_err) {
       let err = Primitive_exceptions.internalToException(raw_err);
       let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err), Stdlib_JsExn.message), "unknown");
@@ -92,4 +92,4 @@ function Make(Spec) {
 export {
   Make,
 }
-/* S Not a pure module */
+/* Effect Not a pure module */

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res

@@ -39,7 +39,7 @@ module Make = (
     // fields entirely, while the consumer side (DcbDecode) parses with the sury
     // schema — a js_nullable option field would reject the missing key and the
     // event would be dropped as schema drift.
-    let json = event->S.reverseConvertToJsonOrThrow(Spec.eventSchema)
+    let json = event->Reventless.Util_Sury.toJson(Spec.eventSchema)
     let (eventType, data) = json->Message.splitMessage
     // Use `extractTagsExpanded` (not `extractTags`) so per-element tags on
     // `array<string>` fields are emitted — e.g. OrderPlaced's
@@ -433,7 +433,7 @@ module Make = (
           | Error(error) =>
             // Business-rule rejection — no append, but the read snapshot is valid; cache it.
             cachePut((state, headPosition))
-            let errorJson = error->S.reverseConvertToJsonOrThrow(Spec.errorSchema)
+            let errorJson = error->Reventless.Util_Sury.toJson(Spec.errorSchema)
             let errorCode = errorJson->Message.variantNameOfJson
             let (_, payloadDict) = errorJson->Message.splitMessage
             let errorDetail =

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -11,6 +10,7 @@ import * as Stream$1 from "effect/Stream";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Lru$ReventlessCore from "../../util/Lru.res.mjs";
 import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as Metrics$ReventlessCore from "../../util/Metrics.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
@@ -186,7 +186,7 @@ function Make(Spec) {
               }
               let rawEvents = newEvents$1.map(e => {
                 let parentMeta = command$p.meta;
-                let json = S.reverseConvertToJsonOrThrow(e, Spec.eventSchema);
+                let json = Util_Sury$Reventless.toJson(e, Spec.eventSchema);
                 let match = Message$ReventlessCore.splitMessage(json);
                 let eventType = match[0];
                 let baseTags = DcbTag$Reventless.extractTagsExpanded(Spec.eventSchema, e);
@@ -272,7 +272,7 @@ function Make(Spec) {
               state,
               headPosition
             ]);
-            let errorJson = S.reverseConvertToJsonOrThrow(newEvents._0, Spec.errorSchema);
+            let errorJson = Util_Sury$Reventless.toJson(newEvents._0, Spec.errorSchema);
             let errorCode = Message$ReventlessCore.variantNameOfJson(errorJson);
             let match = Message$ReventlessCore.splitMessage(errorJson);
             let payloadDict = match[1];
@@ -321,4 +321,4 @@ function Make(Spec) {
 export {
   Make,
 }
-/* S Not a pure module */
+/* Stream Not a pure module */

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -103,7 +103,7 @@ module Make = (
                 // fall back defensively so a malformed envelope never drops the event.
                 let meta = switch envelopeDict->Dict.get("meta") {
                 | Some(m) =>
-                  switch m->S.parseJsonOrThrow(Message.metaSchema) {
+                  switch m->Reventless.Util_Sury.fromJson(Message.metaSchema) {
                   | parsed => parsed
                   | exception _ => Message.generateMeta(~service=Spec.name)
                   }

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

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -12,6 +11,7 @@ import * as Effect from "effect/Effect";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as Component$ReventlessCore from "../Component.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
@@ -87,7 +87,7 @@ function Make(RuntimeEnvironment) {
               let meta;
               if (m !== undefined) {
                 try {
-                  meta = S.parseJsonOrThrow(m, Message$ReventlessCore.metaSchema);
+                  meta = Util_Sury$Reventless.fromJson(m, Message$ReventlessCore.metaSchema);
                 } catch (exn) {
                   meta = Message$ReventlessCore.generateMeta(Spec.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
                 }
@@ -158,4 +158,4 @@ export {
   FrameworkProjection,
   Make,
 }
-/* S Not a pure module */
+/* Stream Not a pure module */

package/src/plugin/api/PluginBaseFragment.res

@@ -1,32 +1,5 @@
 open ReventlessInfra.Api
 
-let adminAuth: Reventless.ReadModel.authorization = {
-  tableName: "Plugin",
-  group: "Admin",
-}
-
-// Fields present on `PluginsReadModelSpec.state` for projection/storage purposes
-// but intentionally absent from the public GraphQL surface. Shared with
-// `Platform_Admin_Structure` so the schema announced via `Platform_ComponentDefinitions`
-// stays aligned with the SDL — otherwise AutoUI generates list-view queries
-// for fields the server doesn't expose and every Plugin row fails to load.
-let pluginExcludeFields: array<string> = [
-  "eventCollector",
-  "extensionPointNames",
-  "extensionNames",
-]
-
-// Additional fields the SDL exposes but the Plugin list view should NOT
-// surface — they're option-of-nested-object types (e.g. apiSchemaFragment,
-// structure) which AutoUI currently renders as scalar columns
-// and queries without a sub-selection, failing schema validation. Other
-// callers (host-shell's Platform_ComponentDefinitions) keep querying them via
-// dedicated fields and resolver paths.
-let pluginUIOnlyExcludeFields: array<string> = pluginExcludeFields->Array.concat([
-  "apiSchemaFragment",
-  "structure",
-])
-
 // Admin read-model query entries are generated from each spec the same way
 // ordinary read models are (Plugin_Builder.res): `subIdField` flows from the
 // spec's `subIdConfig` and `indexQueries` from `config.indexes`, so
@@ -57,8 +30,18 @@ let queryEntries: array<querySchemaEntry> = [
     listFieldName: Api_Naming.adminField(~name="Plugins"),
     returnTypeName: Api_Naming.adminField(~name="Plugin"),
     stateSchema: PluginsReadModelSpec.stateSchema->S.castToUnknown,
-    authorization: Some(adminAuth),
-    excludeFields: pluginExcludeFields,
+    // Read off the spec rather than restated. The hand-written
+    // `{tableName: "Plugin", group: "Admin"}` that used to sit here said the same
+    // thing as `Spec.authorization` in a different type, and the spec's default
+    // (`AllowAuthenticated`) disagreed with it — so the view's rule depended on
+    // which of the two a reader happened to find. The `tableName` half was never
+    // read: the entry path uses only the group, and the per-`@index` auth-table
+    // pipeline params come from `indexConfig.authorization`, which is untouched.
+    authorization: None,
+    permission: PluginsReadModelSpec.authorization,
+    // No `excludeFields`: the three fields this entry used to name are declared
+    // `@internal` on the spec, and `deriveObjectTypeWithNested` reads that off the
+    // schema itself.
     subIdField: ?PluginsReadModelSpec.subIdConfig->Option.map((c: Reventless.ReadModel.subIdConfig<_>) => c.subIdField),
     indexQueries: ?indexQueriesOfConfig(PluginsReadModelSpec.config),
   },

package/src/plugin/api/PluginBaseFragment.res.mjs

@@ -7,22 +7,6 @@ import * as PluginSpec$ReventlessCore from "../lifecycle/PluginSpec.res.mjs";
 import * as ApiNoApiHelpers$ReventlessCore from "../../components/Api/ApiNoApiHelpers.res.mjs";
 import * as PluginsReadModelSpec$ReventlessCore from "../lifecycle/PluginsReadModelSpec.res.mjs";
 
-let adminAuth = {
-  tableName: "Plugin",
-  group: "Admin"
-};
-
-let pluginExcludeFields = [
-  "eventCollector",
-  "extensionPointNames",
-  "extensionNames"
-];
-
-let pluginUIOnlyExcludeFields = pluginExcludeFields.concat([
-  "apiSchemaFragment",
-  "structure"
-]);
-
 function indexQueriesOfConfig(config) {
   if (config.indexes.length !== 0) {
     return config.indexes;
@@ -35,8 +19,8 @@ let queryEntries = [{
     returnTypeName: Api_Naming$ReventlessCore.adminField("Plugin"),
     stateSchema: PluginsReadModelSpec$ReventlessCore.stateSchema,
     specName: PluginsReadModelSpec$ReventlessCore.name,
-    authorization: adminAuth,
-    excludeFields: pluginExcludeFields,
+    authorization: undefined,
+    permission: PluginsReadModelSpec$ReventlessCore.authorization,
     subIdField: Stdlib_Option.map(undefined, c => c.subIdField),
     indexQueries: indexQueriesOfConfig(PluginsReadModelSpec$ReventlessCore.config)
   }];
@@ -53,11 +37,8 @@ let pluginAggregateMutationEntries = fieldNames.length === 0 ? [] : [{
     }];
 
 export {
-  adminAuth,
-  pluginExcludeFields,
-  pluginUIOnlyExcludeFields,
   indexQueriesOfConfig,
   queryEntries,
   pluginAggregateMutationEntries,
 }
-/* pluginUIOnlyExcludeFields Not a pure module */
+/* queryEntries Not a pure module */

package/src/plugin/component/Capability_Inference.res

@@ -55,7 +55,7 @@ let scanSchema = (~component: string, schema: S.t<unknown>): array<warning> => {
     | _ => []
     }
   switch schema {
-  | Union({anyOf}) => anyOf->Array.flatMap(fromVariant)
+  | AnyOf({anyOf}) => anyOf->Array.flatMap(fromVariant)
   | other => fromVariant(other)
   }
 }
@@ -66,3 +66,120 @@ let message = (w: warning): string =>
   `${w.component}.${w.field} looks like a stored-object reference but declares no store — ` ++
   `annotate it \`@storageRef("<store>")\` so the deployment provisions the store it needs, ` ++
   `or rename the field if it holds an external URL. Heuristic matches are never provisioned.`
+
+// ── Near-duplicate stores ──────────────────────────────────────────────────
+//
+// Under name-derived stores a typo does not fail, it *provisions*: `productImage`
+// and `productImgae` both compile, both deploy, and objects split silently
+// across two buckets. Nothing else in the pipeline can see the mistake — both
+// are well-formed declarations — so the check has to live where every store a
+// plugin declares is visible at once.
+//
+// Unlike the heuristic lint above this is a hard failure, and it is meant to be:
+// a warning about infrastructure that was already created is a warning nobody
+// can act on cheaply. A pair that is genuinely two stores settles it by naming
+// one explicitly with `@storageRef("<store>")`.
+
+/** Two store declarations close enough that one is likely a typo for the other. */
+type collision = {
+  a: Reventless.Plugin.requiredStoreDeclaration,
+  b: Reventless.Plugin.requiredStoreDeclaration,
+}
+
+// Exactly the optimal-string-alignment distance ≤ 1: one insert, one delete, one
+// substitution, or one transposition. Written directly rather than as a general
+// distance because a transposition is the shape the motivating typo has
+// (`Images` → `Imgaes`), and a plain Levenshtein scores that 2 and misses it.
+let withinOneEdit = (a: string, b: string): bool => {
+  let (la, lb) = (String.length(a), String.length(b))
+  let charAt = (s, i) => String.charAt(s, i)
+  if la == lb {
+    let diffs = []
+    for i in 0 to la - 1 {
+      if charAt(a, i) != charAt(b, i) {
+        diffs->Array.push(i)
+      }
+    }
+    switch diffs {
+    | [] => true
+    | [_] => true
+    | [i, j] if j == i + 1 =>
+      charAt(a, i) == charAt(b, j) && charAt(a, j) == charAt(b, i)
+    | _ => false
+    }
+  } else if la - lb == 1 || lb - la == 1 {
+    // The longer string with one character removed must equal the shorter one.
+    let (long, short) = la > lb ? (a, b) : (b, a)
+    let rec scan = (~li, ~si, ~skipped) =>
+      if si >= String.length(short) {
+        true
+      } else if charAt(long, li) == charAt(short, si) {
+        scan(~li=li + 1, ~si=si + 1, ~skipped)
+      } else if skipped {
+        false
+      } else {
+        scan(~li=li + 1, ~si, ~skipped=true)
+      }
+    scan(~li=0, ~si=0, ~skipped=false)
+  } else {
+    false
+  }
+}
+
+/** Whether two store names are the same word in different number. Reached only
+    through an explicit `@storageRef` override — a derived name is already
+    pluralised through its singular stem, so two *derived* names cannot differ
+    this way. */
+let sameStem = (a: string, b: string): bool =>
+  Api_Naming.singularize(a) == Api_Naming.singularize(b)
+
+// The unqualified store name and its owning plugin, split off the qualified key
+// the declarations carry.
+let splitKey = (key: string): (string, string) =>
+  switch key->String.split(".") {
+  | [plugin, store] => (plugin, store)
+  | _ => ("", key)
+  }
+
+/**
+Pairs of declared stores that are probably one store misspelled twice.
+
+Compared within an owning plugin only: two plugins may legitimately hold stores
+whose names are one edit apart, and neither can be a typo for the other.
+*/
+let collisions = (
+  declarations: array<Reventless.Plugin.requiredStoreDeclaration>,
+): array<collision> => {
+  // One entry per store, keeping the first declaration site as the one the
+  // message names — several fields naming one store is ordinary, not a clash.
+  let byStore: dict<Reventless.Plugin.requiredStoreDeclaration> = Dict.make()
+  declarations->Array.forEach(d =>
+    switch byStore->Dict.get(d.store) {
+    | Some(_) => ()
+    | None => byStore->Dict.set(d.store, d)
+    }
+  )
+  let unique = byStore->Dict.valuesToArray
+  let found = []
+  for i in 0 to Array.length(unique) - 1 {
+    for j in i + 1 to Array.length(unique) - 1 {
+      let a = unique->Array.getUnsafe(i)
+      let b = unique->Array.getUnsafe(j)
+      let (pluginA, storeA) = splitKey(a.store)
+      let (pluginB, storeB) = splitKey(b.store)
+      if pluginA == pluginB && (withinOneEdit(storeA, storeB) || sameStem(storeA, storeB)) {
+        found->Array.push({a, b})->ignore
+      }
+    }
+  }
+  found
+}
+
+/** The failure text: name both stores and both declaration sites, so a pair that
+    is genuinely two stores is diagnosed in one reading. */
+let collisionMessage = (c: collision): string =>
+  `${c.a.store} (${c.a.component}.${c.a.field}) and ${c.b.store} ` ++
+  `(${c.b.component}.${c.b.field}) differ by one edit — one is probably a typo for ` ++
+  `the other, and both would be provisioned, splitting objects across two stores. ` ++
+  `Fix the field name, or name the store explicitly with \`@storageRef("<store>")\` ` ++
+  `if the two really are separate stores.`