@reventlessdev/reventless-spec 3.0.0-alpha.130 → 3.0.0-alpha.132

package/src/lifecycle/loadPluginStructure.mjs

@@ -0,0 +1,66 @@
+// Reading a built plugin's declared structure.
+//
+// A plugin's generated definition module is a functor over the platform type
+// that exposes `pluginStructure` as an ordinary value, and the local platform's
+// `Make` takes no configuration — so applying one to the other is enough to hold
+// a real structure. No deploy program, no database, no server, nothing left
+// running.
+//
+// This lives in a companion `.mjs` because it is untyped reflection: `import` is
+// syntax rather than a value, so a computed specifier cannot be bound as an
+// external, and the value that comes back is shaped by the plugin rather than by
+// anything this repository can name.
+//
+// The structure is handed back as plain JSON and read field by field on the
+// ReScript side, rather than parsed through the published schema. A
+// `pluginStructure` has two legitimate representations — an absent optional is
+// `undefined` in memory and an explicit `null` on the wire — and the published
+// schema describes the wire form, so validating an in-memory structure against
+// it fails on every optional that happens to be empty.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+const localPlatformPath = (pluginDir) =>
+  join(
+    pluginDir,
+    "node_modules/@reventlessdev/reventless-local/src/Platform.res.mjs",
+  );
+
+const pluginEntryPath = (pluginDir) => join(pluginDir, "src/Plugin.res.mjs");
+
+/**
+ * @returns {Promise<{ok: true, structure: unknown} | {ok: false, error: string}>}
+ */
+export const loadPluginStructure = async (pluginDir) => {
+  const entry = pluginEntryPath(pluginDir);
+  const local = localPlatformPath(pluginDir);
+  if (!existsSync(entry)) {
+    return {
+      ok: false,
+      error: `no compiled plugin at ${entry} — build the plugin first`,
+    };
+  }
+  if (!existsSync(local)) {
+    return {
+      ok: false,
+      error: `no local platform installed at ${local}`,
+    };
+  }
+  try {
+    const localMod = await import(local);
+    const pluginMod = await import(entry);
+    const structure = pluginMod.Make(localMod.Make()).pluginStructure;
+    // A structure whose component arrays are absent came from a release this
+    // reader cannot understand. Saying so beats reporting a model that is
+    // quietly half-empty.
+    const present = ["readModels", "stateViewSlices", "stateChangeSlices", "aggregates"].every(
+      (k) => Array.isArray(structure?.[k]),
+    );
+    return present
+      ? { ok: true, structure }
+      : { ok: false, error: "the plugin structure declares no component arrays" };
+  } catch (e) {
+    const message = e && (e.message || e.RE_EXN_ID) ? String(e.message || e.RE_EXN_ID) : "unknown error";
+    return { ok: false, error: `reading the plugin structure: ${message}` };
+  }
+};

package/src/semantic/CalendarDate.res

@@ -0,0 +1,58 @@
+/**
+Marks a `string` field as a calendar day — `2026-03-02`, with no instant in it.
+
+## Why this is not a `DateTime`
+
+A birth date, a due date, an invoice date, an `effectiveFrom` — the value has no
+time of day, and storing one as an instant creates the midnight bug: a renderer
+that localizes `2026-03-02T00:00:00Z` shows *March 1st* to every reader west of
+Greenwich. That is a wrong date on a screen produced by a correct renderer, and
+no annotation can repair it, because the value itself has lost the distinction.
+
+## The grammar
+
+Sury's `S.isoDate`: `2026-03-02` accepts, `2026-13-02`, `09:00:00`,
+`2026-03-02T09:00:00Z` and the empty string all reject. It emits
+`format: "date"`, the standard JSON Schema keyword a consumer already reads.
+
+## Why `CalendarDate` and not `Date`
+
+`reventless-spec` compiles with `-open RescriptCore`, and its own modules resolve
+unqualified inside the package — so a `Date.res` here would shadow the stdlib
+`Date` for every file in it. The wire vocabulary id stays the short `"date"`;
+only the module name carries the qualifier.
+
+@example
+```rescript
+@schema
+type state = {
+  invoiceId: string,
+  issuedOn: Reventless.CalendarDate.t,
+}
+```
+*/
+
+/** The day's representation. Transparent `string`, like the rest of the branded
+    scalars: the marker refines an existing field rather than replacing it. */
+type t = string
+
+external unsafe: string => t = "%identity"
+external toString: t => string = "%identity"
+
+// Sury's rule, held once. `fromString` runs it rather than restating it, and
+// `schema` is built from `fromString`, so there is exactly one grammar here.
+let grammar: S.t<string> = S.isoDate
+
+/** Validate a raw string as an ISO-8601 calendar day, saying why when it is not one. */
+let fromString = (raw: string): result<t, string> =>
+  switch raw->S.parseOrThrow(~to=grammar) {
+  | value => Ok(value)
+  | exception _ => Error(`expected a calendar date (YYYY-MM-DD), got ${Semantic.showString(raw)}`)
+  }
+
+/** The sury schema for a calendar-date field. Write the field's type as
+    `Reventless.CalendarDate.t` and sury-ppx resolves it. */
+let schema: S.t<t> = S.string->Semantic.refined(~id=Semantic.Id.date, ~check=fromString)
+
+/** Whether a field schema carries the calendar-date marker. */
+let isCalendarDate = (fieldSchema: S.t<unknown>) => fieldSchema->Semantic.has(~id=Semantic.Id.date)

package/src/semantic/CalendarDate.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
+import * as Semantic$Reventless from "./Semantic.res.mjs";
+
+let grammar = Sury.isoDate;
+
+function fromString(raw) {
+  let value;
+  try {
+    value = S.parseOrThrow(raw, grammar);
+  } catch (exn) {
+    return {
+      TAG: "Error",
+      _0: `expected a calendar date (YYYY-MM-DD), got ` + Semantic$Reventless.showString(raw)
+    };
+  }
+  return {
+    TAG: "Ok",
+    _0: value
+  };
+}
+
+let schema = Semantic$Reventless.refined(Sury.string, Semantic$Reventless.Id.date, fromString);
+
+function isCalendarDate(fieldSchema) {
+  return Semantic$Reventless.has(fieldSchema, Semantic$Reventless.Id.date);
+}
+
+export {
+  grammar,
+  fromString,
+  schema,
+  isCalendarDate,
+}
+/* grammar Not a pure module */

package/src/semantic/DateRange.res

@@ -41,10 +41,10 @@ who assumes parity with `Money` assumes wrong. When sury fixes the record
 refinement the rule moves into the schema and `validate` stays as its single
 definition — the relationship `Money.validateAmount` has with `amountSchema`.
 
-Parsing is `Date.fromString` on each instant. A range whose strings do not parse
-is a decode-time problem the `DateTime` marker does not currently catch either,
-so there is no second validation layer here — a reversed *parseable* range is
-what `validate` catches, and an unparseable one is out of both their scope.
+The *parts* are checked, though, and by their own type rather than by anything
+here: each is a `DateTime`, so a string that is not a UTC instant is rejected at
+decode. What is left for `validate` is the one rule that relates the two — a
+range whose instants both parse, the earlier one second.
 
 ## How a field declares it
 
@@ -70,12 +70,12 @@ projection rebuild. It costs a log something only if it *collapses* an existing
 @schema
 type t = {
   /** The instant the range opens, inclusive. */
-  start: @s.matches(DateTime.string) string,
+  start: DateTime.t,
   /** The instant the range closes, **exclusive** — the range does not contain
       it. `@as("end")` puts `end` on the wire (where the UI's own `GanttChart`
       already spells it that way); `end_` is the source spelling because `end`
       is awkward as a bare ReScript field. */
-  @as("end") end_: @s.matches(DateTime.string) string,
+  @as("end") end_: DateTime.t,
 }
 
 /** The sury schema for a date-range field, carrying the `dateRange` semantic.
@@ -85,10 +85,10 @@ type t = {
     is deliberately *not* refined in here — see the module doc. */
 let schema: S.t<t> = schema->Semantic.mark(~id=Semantic.Id.dateRange)
 
-/** An instant as milliseconds since the epoch — `NaN` if it does not parse. The
-    one place a range's strings become numbers, so end-exclusivity and the
-    ordering rule are all expressed against a single parse. */
-let millis = (instant: string): float => instant->Date.fromString->Date.getTime
+/** An instant as milliseconds since the epoch. `DateTime`'s, so end-exclusivity
+    and the ordering rule are expressed against the same single parse the type
+    itself uses rather than a second copy of it here. */
+let millis = DateTime.millis
 
 /**
 Validate a range's ordering, saying why when it is reversed.

package/src/semantic/DateRange.res.mjs

@@ -1,22 +1,18 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Sury from "sury";
-import * as DateTime$Reventless from "../types/DateTime.res.mjs";
+import * as DateTime$Reventless from "./DateTime.res.mjs";
 import * as Semantic$Reventless from "./Semantic.res.mjs";
 
 let schema = Sury.$schema(s => ({
-  start: s.m(DateTime$Reventless.string),
-  end: s.m(DateTime$Reventless.string)
+  start: s.m(DateTime$Reventless.schema),
+  end: s.m(DateTime$Reventless.schema)
 }));
 
 let schema$1 = Semantic$Reventless.mark(schema, Semantic$Reventless.Id.dateRange, undefined);
 
-function millis(instant) {
-  return new Date(instant).getTime();
-}
-
 function validate(range) {
-  if (new Date(range.start).getTime() > new Date(range.end).getTime()) {
+  if (DateTime$Reventless.millis(range.start) > DateTime$Reventless.millis(range.end)) {
     return {
       TAG: "Error",
       _0: `a range ends before it starts: ` + range.start + ` is after ` + range.end + `. A range is [start, end) — the start is the earlier instant.`
@@ -37,21 +33,21 @@ function make(start, end_) {
 }
 
 function duration(range) {
-  return Math.trunc((new Date(range.end).getTime() - new Date(range.start).getTime()) / 1000.0) | 0;
+  return Math.trunc((DateTime$Reventless.millis(range.end) - DateTime$Reventless.millis(range.start)) / 1000.0) | 0;
 }
 
 function contains(range, instant) {
-  let t = new Date(instant).getTime();
-  if (t >= new Date(range.start).getTime()) {
-    return t < new Date(range.end).getTime();
+  let t = DateTime$Reventless.millis(instant);
+  if (t >= DateTime$Reventless.millis(range.start)) {
+    return t < DateTime$Reventless.millis(range.end);
   } else {
     return false;
   }
 }
 
 function overlaps(a, b) {
-  if (new Date(a.start).getTime() < new Date(b.end).getTime()) {
-    return new Date(b.start).getTime() < new Date(a.end).getTime();
+  if (DateTime$Reventless.millis(a.start) < DateTime$Reventless.millis(b.end)) {
+    return DateTime$Reventless.millis(b.start) < DateTime$Reventless.millis(a.end);
   } else {
     return false;
   }
@@ -61,6 +57,8 @@ function format(range) {
   return range.start + ` – ` + range.end;
 }
 
+let millis = DateTime$Reventless.millis;
+
 export {
   schema$1 as schema,
   millis,

package/src/semantic/DateTime.res

@@ -0,0 +1,92 @@
+/**
+Marks a `string` field as an ISO-8601 instant.
+
+## The grammar
+
+Sury's `S.isoDateTime`, and nothing added — the same rule the branded scalars
+follow. `S.datetime` is the other binding and is not this one: it *transforms* to
+`Js.Date.t`, changing the field's runtime type, where this keeps the string the
+projection wrote.
+
+## UTC only
+
+`S.isoDateTime` accepts a `Z` instant and rejects an offset — `2026-03-02T09:00:00+01:00`
+and a bare `2026-03-02T09:00:00` both fail. That is stricter than RFC 3339 and it
+is the strictness worth adopting: every instant the framework produces comes from
+`Message.nowAsISOString`, which is always `Z`. "Instants are stored in UTC" is a
+fact a reader can rely on; "we accept whatever offset arrived" pushes the zone
+question onto every consumer.
+
+An inbound feed carrying a supplier's local offset converts at the boundary,
+which is what an `InboundTranslation` slice is for — `Date.fromString` then
+`toISOString`. Forgetting it is now a rejection rather than a row nobody can sort.
+
+`SchemaType`/`SuryToJsonSchema` surface the marker as `format: "date-time"` on
+the field's JSON Schema, which the AutoUI date heuristics key off (CalendarView,
+TimelineView, date-axis charts).
+
+A date with no instant in it — a birth date, a due date — is `CalendarDate`, not
+this. Storing one as an instant creates the midnight bug.
+
+@example
+```rescript
+@schema
+type state = {
+  orderId: string,
+  placedAt: Reventless.DateTime.t,
+  shippedAt: option<Reventless.DateTime.t>,
+}
+```
+*/
+
+/** The instant's representation. Transparent `string`: the marker refines an
+    existing field rather than replacing it, so nothing stored changes, and
+    `placedAt: meta.time` keeps compiling. */
+type t = string
+
+external unsafe: string => t = "%identity"
+external toString: t => string = "%identity"
+
+// Sury's rule, held once. `fromString` runs it rather than restating it, and
+// `schema` is built from `fromString`, so there is exactly one grammar here.
+let grammar: S.t<string> = S.isoDateTime
+
+/** Validate a raw string as a UTC ISO-8601 instant, saying why when it is not one. */
+let fromString = (raw: string): result<t, string> =>
+  switch raw->S.parseOrThrow(~to=grammar) {
+  | value => Ok(value)
+  | exception _ =>
+    Error(`expected a UTC ISO-8601 instant, got ${Semantic.showString(raw)}`)
+  }
+
+/** The sury schema for an instant field. Use with `@s.matches(Reventless.DateTime.schema)`,
+    or write the field's type as `Reventless.DateTime.t` and let sury-ppx resolve it. */
+let schema: S.t<t> = S.string->Semantic.refined(~id=Semantic.Id.dateTime, ~check=fromString)
+
+/** A sury string schema annotated as an instant, without the grammar.
+
+    @deprecated Use `schema`, which carries the same marker and checks the value. */
+let string: S.t<string> = S.string->Semantic.mark(~id=Semantic.Id.dateTime)
+
+/** Whether a field schema carries the date-time marker. */
+let isDateTime = (fieldSchema: S.t<unknown>) => fieldSchema->Semantic.has(~id=Semantic.Id.dateTime)
+
+/** An instant as milliseconds since the epoch — `NaN` if it does not parse. The
+    one place an instant becomes a number, so every comparison here and in
+    `DateRange` is expressed against a single parse. */
+let millis = (instant: t): float => instant->Date.fromString->Date.getTime
+
+/** Whether one instant is strictly earlier than another. */
+let isBefore = (a: t, b: t): bool => millis(a) < millis(b)
+
+/** Order two instants, oldest first. */
+let compare = (a: t, b: t) => Float.compare(millis(a), millis(b))
+
+/** The instant as text, to the minute, in UTC — `"2026-03-02 09:00"`.
+    Locale-independent, the way `Money.format` and `Duration.format` are: the
+    same value reads the same in every log line and every test. A value that is
+    not the shape the grammar admits reads back unchanged. */
+let format = (instant: t): string =>
+  String.length(instant) >= 16
+    ? String.slice(instant, ~start=0, ~end=10) ++ " " ++ String.slice(instant, ~start=11, ~end=16)
+    : instant

package/src/semantic/DateTime.res.mjs

@@ -0,0 +1,65 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
+import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
+import * as Semantic$Reventless from "./Semantic.res.mjs";
+
+let grammar = Sury.isoDateTime;
+
+function fromString(raw) {
+  let value;
+  try {
+    value = S.parseOrThrow(raw, grammar);
+  } catch (exn) {
+    return {
+      TAG: "Error",
+      _0: `expected a UTC ISO-8601 instant, got ` + Semantic$Reventless.showString(raw)
+    };
+  }
+  return {
+    TAG: "Ok",
+    _0: value
+  };
+}
+
+let schema = Semantic$Reventless.refined(Sury.string, Semantic$Reventless.Id.dateTime, fromString);
+
+let string = Semantic$Reventless.mark(Sury.string, Semantic$Reventless.Id.dateTime, undefined);
+
+function isDateTime(fieldSchema) {
+  return Semantic$Reventless.has(fieldSchema, Semantic$Reventless.Id.dateTime);
+}
+
+function millis(instant) {
+  return new Date(instant).getTime();
+}
+
+function isBefore(a, b) {
+  return new Date(a).getTime() < new Date(b).getTime();
+}
+
+function compare(a, b) {
+  return Primitive_float.compare(new Date(a).getTime(), new Date(b).getTime());
+}
+
+function format(instant) {
+  if (instant.length >= 16) {
+    return instant.slice(0, 10) + " " + instant.slice(11, 16);
+  } else {
+    return instant;
+  }
+}
+
+export {
+  grammar,
+  fromString,
+  schema,
+  string,
+  isDateTime,
+  millis,
+  isBefore,
+  compare,
+  format,
+}
+/* grammar Not a pure module */

package/src/semantic/RowImage.res

@@ -0,0 +1,122 @@
+/**
+The picture a row is shown by, wherever a row is shown as a reference to it.
+
+## Why this is derived once, here
+
+The reference door (`{list}Refs`) names a row for a caller holding a pointer to
+it, and a card or a tile that draws such a reference wants its picture for the
+same reason it wants its name. Three backends answer that door — an AppSync
+resolver over DynamoDB, the Postgres query Lambda, and the local GraphQL server
+— and a rule about "where a row keeps its picture" spelled three times is a rule
+the three would eventually disagree about. So the *field* is found once, from the
+state schema, and each backend only reads it out.
+
+## What counts as the picture
+
+The first field, in declaration order, carrying an image semantic:
+`uploadableImage` or `imageRef` (the field's value IS the ref) or
+`captionedImage` (the ref sits inside the record, beside its text). A field
+holding a set of them is read at `[0]`, because a set puts the primary member
+first — the same member a card, a gallery tile and a list cell already draw.
+
+Declaration order rather than a name rule: a view with two image fields has
+already said which one comes first, and guessing from names would let a field
+called `thumbnail` outrank the one the author put at the top.
+*/
+
+/** Where the ref string sits, relative to the field that carries it. */
+type shape =
+  | /** The field's own value is the ref. */ Scalar
+  | /** The ref is one member of the field's record. */ Member(string)
+
+type source = {
+  field: string,
+  shape: shape,
+  /** The field holds a set, and the row is shown by its first member. */
+  fromArray: bool,
+}
+
+/** `CaptionedImage`'s own name for the reference it wraps. Named here rather
+    than spelled at each reader: the record is this package's, so a rename would
+    otherwise be caught nowhere. */
+let captionedImageMember = "ref"
+
+let shapeOf = (schema: S.t<unknown>): option<shape> =>
+  switch Semantic.getFrom(schema) {
+  | Some({id}) if id === Semantic.Id.uploadableImage || id === Semantic.Id.imageRef => Some(Scalar)
+  | Some({id}) if id === Semantic.Id.captionedImage => Some(Member(captionedImageMember))
+  | _ => None
+  }
+
+// sury keeps a homogeneous element schema in `additionalItems` and a tuple's
+// positional schemas in `items`; both are read, as `StorageRef.getFieldStore`
+// does, so the marker is found wherever the element sits.
+let elementOf = (schema: S.t<unknown>): option<S.t<unknown>> =>
+  switch schema {
+  | Array({items, additionalItems}) =>
+    switch items->Array.get(0) {
+    | Some(_) as element => element
+    | None =>
+      switch additionalItems {
+      | Schema(element) => Some(element)
+      | _ => None
+      }
+    }
+  | _ => None
+  }
+
+let sourceOfField = (~field: string, schema: S.t<unknown>): option<source> => {
+  // The marker on an optional field lives inside the wrapper, and an array's
+  // lives on its element — so both are stepped through before asking.
+  let unwrapped = schema->Semantic.unwrapOptional->Option.getOr(schema)
+  switch shapeOf(unwrapped) {
+  | Some(shape) => Some({field, shape, fromArray: false})
+  | None =>
+    unwrapped
+    ->elementOf
+    ->Option.flatMap(shapeOf)
+    ->Option.map(shape => {field, shape, fromArray: true})
+  }
+}
+
+/** The field a reference to this row shows it by, or nothing where the view
+    declares no picture — which is most of them. */
+let sourceFrom = (stateSchema: S.t<unknown>): option<source> =>
+  switch stateSchema {
+  | Object({properties}) =>
+    properties
+    ->Dict.toArray
+    ->Array.filterMap(((field, schema)) => sourceOfField(~field, schema))
+    ->Array.get(0)
+  | _ => None
+  }
+
+/** The ref one row carries, read out of the stored item. An empty string is read
+    as absent: a projection that wrote a placeholder said nothing about a
+    picture, and a consumer resolving `""` against a store gets a broken tile. */
+let refFrom = (row: dict<JSON.t>, source: source): option<string> => {
+  let value = row->Dict.get(source.field)
+  let value = source.fromArray
+    ? value->Option.flatMap(JSON.Decode.array)->Option.flatMap(members => members->Array.get(0))
+    : value
+  switch source.shape {
+  | Scalar => value->Option.flatMap(JSON.Decode.string)
+  | Member(member) =>
+    value
+    ->Option.flatMap(JSON.Decode.object)
+    ->Option.flatMap(d => d->Dict.get(member))
+    ->Option.flatMap(JSON.Decode.string)
+  }->Option.filter(ref => ref != "")
+}
+
+/** The same read as a JavaScript expression, for the one backend whose resolver
+    is generated source rather than a function: the AppSync template. `null`
+    where the row carries nothing, which is what the field's type promises. */
+let jsExpr = (~row: string, source: source): string => {
+  let at = `${row}['${source.field}']`
+  let at = source.fromArray ? `(${at} ?? [])[0]` : at
+  switch source.shape {
+  | Scalar => `${at} ?? null`
+  | Member(member) => `${at}?.['${member}'] ?? null`
+  }
+}

package/src/semantic/RowImage.res.mjs

@@ -0,0 +1,101 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 Semantic$Reventless from "./Semantic.res.mjs";
+
+let captionedImageMember = "ref";
+
+function shapeOf(schema) {
+  let match = Semantic$Reventless.getFrom(schema);
+  if (match === undefined) {
+    return;
+  }
+  let id = match.id;
+  if (id === Semantic$Reventless.Id.uploadableImage || id === Semantic$Reventless.Id.imageRef) {
+    return "Scalar";
+  } else if (id === Semantic$Reventless.Id.captionedImage) {
+    return {
+      TAG: "Member",
+      _0: captionedImageMember
+    };
+  } else {
+    return;
+  }
+}
+
+function elementOf(schema) {
+  if (schema.type !== "array") {
+    return;
+  }
+  let additionalItems = schema.additionalItems;
+  let element = schema.items[0];
+  if (element !== undefined) {
+    return element;
+  } else if (additionalItems === "strip" || additionalItems === "strict") {
+    return;
+  } else {
+    return additionalItems;
+  }
+}
+
+function sourceOfField(field, schema) {
+  let unwrapped = Stdlib_Option.getOr(Semantic$Reventless.unwrapOptional(schema), schema);
+  let shape = shapeOf(unwrapped);
+  if (shape !== undefined) {
+    return {
+      field: field,
+      shape: shape,
+      fromArray: false
+    };
+  } else {
+    return Stdlib_Option.map(Stdlib_Option.flatMap(elementOf(unwrapped), shapeOf), shape => ({
+      field: field,
+      shape: shape,
+      fromArray: true
+    }));
+  }
+}
+
+function sourceFrom(stateSchema) {
+  if (stateSchema.type === "object") {
+    return Stdlib_Array.filterMap(Object.entries(stateSchema.properties), param => sourceOfField(param[0], param[1]))[0];
+  }
+}
+
+function refFrom(row, source) {
+  let value = row[source.field];
+  let value$1 = source.fromArray ? Stdlib_Option.flatMap(Stdlib_Option.flatMap(value, Stdlib_JSON.Decode.array), members => members[0]) : value;
+  let member = source.shape;
+  let tmp;
+  if (typeof member !== "object") {
+    tmp = Stdlib_Option.flatMap(value$1, Stdlib_JSON.Decode.string);
+  } else {
+    let member$1 = member._0;
+    tmp = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(value$1, Stdlib_JSON.Decode.object), d => d[member$1]), Stdlib_JSON.Decode.string);
+  }
+  return Stdlib_Option.filter(tmp, ref => ref !== "");
+}
+
+function jsExpr(row, source) {
+  let at = row + `['` + source.field + `']`;
+  let at$1 = source.fromArray ? `(` + at + ` ?? [])[0]` : at;
+  let member = source.shape;
+  if (typeof member !== "object") {
+    return at$1 + ` ?? null`;
+  } else {
+    return at$1 + `?.['` + member._0 + `'] ?? null`;
+  }
+}
+
+export {
+  captionedImageMember,
+  shapeOf,
+  elementOf,
+  sourceOfField,
+  sourceFrom,
+  refFrom,
+  jsExpr,
+}
+/* Semantic-Reventless Not a pure module */

package/src/semantic/Semantic.res

@@ -59,6 +59,9 @@ type t = {id: string, payload: payload}
     `x-reventless-semantic` carries, shared with the annotation path. */
 module Id = {
   let dateTime = "dateTime"
+  // A day with no instant in it. Separate from `dateTime` because storing one as
+  // an instant is what produces the midnight bug — see `CalendarDate`.
+  let date = "date"
   let reference = "reference"
   let storageRef = "storageRef"
   // Like `storageRef`, but inline-or-reference rather than always a ref path.
@@ -101,6 +104,11 @@ module Id = {
   // A lat/lng pair. Cheapest to adopt: `{lat, lng}` is already the stored shape.
   let geoPoint = "geoPoint"
 
+  // The ordered record of the states a row has been through. Marks a shape
+  // rather than a scalar's meaning, and rides here anyway: this is the marker
+  // the schema walk emits, so anything else would be invisible on the wire.
+  let lifecycleTrail = "lifecycleTrail"
+
   // The first composite that is a union rather than an object. Collapses fields,
   // so adopting it changes the wire and rebuilds a derived view.
   let geolocation = "geolocation"