@reventlessdev/reventless-postgres 3.0.0-alpha.2 → 3.0.0-alpha.4

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1783255232307)
-#Done(1783255234016)
+#Start(1783261249645)
+#Done(1783261251603)

package/lib/ocaml/EventLogChangeFeed.res

@@ -0,0 +1,184 @@
+// Classic `event_log` change feed (B2.5) — the aggregate-path analogue of
+// `PgChangeFeed` (which serves the DCB `dcb_event` log).
+//
+// Like the DCB feed this is NOT logical decoding: classic events are already
+// durably queryable in-table, so the feed is an xmin-fenced read over `event_log`
+// plus an `event_log_subscription` checkpoint. A statement-level AFTER INSERT
+// trigger (`event_log_notify`, see PgSchema) issues `pg_notify('evlog_<log>')`,
+// turning polling into near-real-time wakeup; a low-frequency fallback tick in the
+// consumer covers missed notifications.
+//
+// Cursor semantics mirror the DCB feed exactly: the opaque `<xid8>:<global_seq>`
+// string (zero-padded so string order == numeric order). Reads apply the xmin
+// barrier (`transaction_id < pg_snapshot_xmin(pg_current_snapshot())`), so a
+// returned cursor is stable forever — an event committed late (lower global_seq,
+// later commit) is never skipped by a checkpointing reader. `global_seq` alone,
+// being an IDENTITY assigned at INSERT, could NOT provide that guarantee.
+
+// Reuse the shared `<a>:<b>` cursor codec from the DCB storage — identical format.
+module Dcb = DcbEventLogStorage_Postgres
+
+// One classic event as the feed surfaces it. `payload` is the stored event JSON
+// verbatim; a bus/topic relay transforms it into its target shape (e.g. the AWS
+// EventCollector `{id, meta, event}` body) — that transform is not this package's
+// concern.
+type classicEvent = {
+  cursor: string,
+  aggregateId: string,
+  seqNr: int,
+  payload: JSON.t,
+  msgId: option<string>,
+}
+
+// One page of the feed. `events` are in (transaction_id, global_seq) order;
+// `cursor` is the checkpoint to persist and to pass as the next `after` (None when
+// the page was empty — nothing new).
+type batch = {
+  events: array<classicEvent>,
+  cursor: option<string>,
+}
+
+let selectColumns = "
+  lpad(transaction_id::text, 20, '0') || ':' || lpad(global_seq::text, 20, '0') AS cursor,
+  aggregate_id,
+  seq_nr,
+  payload,
+  msg_id
+"
+
+let coerceInt = (v: JSON.t): int =>
+  switch v {
+  | JSON.Number(n) => Float.toInt(n)
+  | JSON.String(s) => s->Int.fromString->Option.getOr(0)
+  | _ => 0
+  }
+
+let rowToEvent = (row: dict<JSON.t>): classicEvent => {
+  let str = key =>
+    switch row->Dict.get(key) {
+    | Some(JSON.String(s)) => s
+    | _ => ""
+    }
+  {
+    cursor: str("cursor"),
+    aggregateId: str("aggregate_id"),
+    seqNr: row->Dict.get("seq_nr")->Option.map(coerceInt)->Option.getOr(0),
+    payload: row->Dict.get("payload")->Option.getOr(JSON.Encode.null),
+    msgId: switch row->Dict.get("msg_id") {
+    | Some(JSON.String(s)) => Some(s)
+    | _ => None
+    },
+  }
+}
+
+// Read up to `limit` events after `after` (the xmin-fenced feed query — whole log).
+// Returns the events and the cursor of the last one.
+let readBatch = async (
+  pool: PgDriver.pool,
+  ~logName: string,
+  ~after: option<string>=?,
+  ~limit: int=500,
+): batch => {
+  let params = [JSON.Encode.string(logName)]
+  let where = ref("log_name = $1 AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())")
+  switch after->Option.flatMap(Dcb.decodeCursor) {
+  | Some((tx, pos)) =>
+    // $2 = tx (referenced twice), $3 = global_seq.
+    params->Array.push(JSON.Encode.string(tx))
+    params->Array.push(JSON.Encode.string(pos))
+    where :=
+      where.contents ++
+      " AND (transaction_id > $2::xid8 OR (transaction_id = $2::xid8 AND global_seq > $3::bigint))"
+  | None => ()
+  }
+  let sql = `SELECT ${selectColumns} FROM event_log WHERE ${where.contents} ORDER BY transaction_id ASC, global_seq ASC LIMIT ${Int.toString(limit)}`
+  let rows = await pool->PgDriver.query(sql, params)
+  let events = rows->Array.map(rowToEvent)
+  let cursor = switch events->Array.get(events->Array.length - 1) {
+  | Some(last) => Some(last.cursor)
+  | None => None
+  }
+  {events, cursor}
+}
+
+// --- Checkpoint contract (event_log_subscription) ---
+
+// The persisted checkpoint for `subscriber`, encoded as a cursor, or None if the
+// subscriber has never committed (→ replay from the beginning).
+let loadCheckpoint = async (pool: PgDriver.pool, ~subscriber: string): option<string> =>
+  switch await pool->PgDriver.queryOne(
+    "SELECT lpad(last_tx::text, 20, '0') || ':' || lpad(last_global_seq::text, 20, '0') AS cursor
+       FROM event_log_subscription WHERE subscriber = $1 AND last_global_seq > 0",
+    [JSON.Encode.string(subscriber)],
+  ) {
+  | Some(row) =>
+    switch row->Dict.get("cursor") {
+    | Some(JSON.String(s)) => Some(s)
+    | _ => None
+    }
+  | None => None
+  }
+
+// Persist the checkpoint. Idempotent upsert; decodes the cursor to its two columns
+// so a later `loadCheckpoint` round-trips exactly.
+let saveCheckpoint = async (pool: PgDriver.pool, ~subscriber: string, ~cursor: string): unit =>
+  switch Dcb.decodeCursor(cursor) {
+  | Some((tx, pos)) =>
+    let _ = await pool->PgDriver.query(
+      "INSERT INTO event_log_subscription(subscriber, last_tx, last_global_seq)
+       VALUES ($1, $2::xid8, $3::bigint)
+       ON CONFLICT (subscriber)
+       DO UPDATE SET last_tx = EXCLUDED.last_tx, last_global_seq = EXCLUDED.last_global_seq",
+      [JSON.Encode.string(subscriber), JSON.Encode.string(tx), JSON.Encode.string(pos)],
+    )
+  | None => ()
+  }
+
+// --- Wakeup ---
+
+// LISTEN on `evlog_<logName>`; `onWake` fires on every notification. Returns the
+// dedicated client (caller owns it — release via unlisten). Pair with a
+// low-frequency fallback tick so a missed NOTIFY only adds latency, never a stall.
+let listen = (pool: PgDriver.pool, ~logName: string, ~onWake: unit => unit): promise<
+  PgDriver.client,
+> => pool->PgDriver.listen(~channel="evlog_" ++ logName, ~onNotify=_ => onWake())
+
+let unlisten = (client: PgDriver.client, ~logName: string): promise<unit> =>
+  client->PgDriver.unlisten(~channel="evlog_" ++ logName)
+
+// --- Reference consumer driver ---
+
+// Drain the feed for `subscriber` from its checkpoint: repeatedly readBatch →
+// `handle` the events → saveCheckpoint, until a short page. `handle` must be
+// idempotent (a crash between handle and checkpoint replays the last batch).
+// Returns the number of events processed.
+let drain = async (
+  pool: PgDriver.pool,
+  ~logName: string,
+  ~subscriber: string,
+  ~limit: int=500,
+  ~handle: array<classicEvent> => promise<unit>,
+): int => {
+  let processed = ref(0)
+  let cursor = ref(await loadCheckpoint(pool, ~subscriber))
+  let continue = ref(true)
+  while continue.contents {
+    let {events, cursor: newCursor} = await readBatch(pool, ~logName, ~after=?cursor.contents, ~limit)
+    if events->Array.length == 0 {
+      continue := false
+    } else {
+      await handle(events)
+      switch newCursor {
+      | Some(c) =>
+        await saveCheckpoint(pool, ~subscriber, ~cursor=c)
+        cursor := Some(c)
+      | None => ()
+      }
+      processed := processed.contents + events->Array.length
+      if events->Array.length < limit {
+        continue := false
+      }
+    }
+  }
+  processed.contents
+}

package/lib/ocaml/PgSchema.res

@@ -36,6 +36,19 @@ let tableStatements = [
      schema_hash   text   NOT NULL,
      PRIMARY KEY (log_name, aggregate_id)
    )",
+  // --- Classic change feed (B2.5) ---
+  // Stamp every classic event with its committing xid8 so the feed can apply the
+  // same xmin read barrier the DCB feed uses — global_seq (an IDENTITY assigned at
+  // INSERT, before commit) is unsafe as a feed cursor on its own (a late-committing
+  // lower global_seq would be skipped). Idempotent; the volatile default auto-stamps
+  // every future insert with no change to EventLogStorage_Postgres.append.
+  "ALTER TABLE event_log ADD COLUMN IF NOT EXISTS transaction_id xid8 NOT NULL DEFAULT pg_current_xact_id()",
+  "CREATE INDEX IF NOT EXISTS event_log_tx_gseq ON event_log (log_name, transaction_id, global_seq)",
+  "CREATE TABLE IF NOT EXISTS event_log_subscription (
+     subscriber      text   PRIMARY KEY,
+     last_tx         xid8   NOT NULL DEFAULT '0'::xid8,
+     last_global_seq bigint NOT NULL DEFAULT 0
+   )",
   // --- DCB event log (Phase B) ---
   "CREATE TABLE IF NOT EXISTS dcb_event (
      log_name        text        NOT NULL,
@@ -236,7 +249,28 @@ END;
 $fn$;
 "
 
-let functionStatements = [dcbConditionWhereFn, dcbAppendFn]
+// Classic change-feed wakeup (B2.5). A statement-level AFTER INSERT trigger fires
+// one pg_notify per distinct log_name touched by the statement, so the classic feed
+// gets the same near-real-time wakeup the DCB append's inline pg_notify provides —
+// without touching EventLogStorage_Postgres.append. No-op if nobody is LISTENing; a
+// low-frequency fallback tick in the consumer covers missed notifications.
+let eventLogNotifyFn = "
+CREATE OR REPLACE FUNCTION event_log_notify() RETURNS trigger
+LANGUAGE plpgsql AS $fn$
+BEGIN
+  PERFORM pg_notify('evlog_' || log_name, '')
+    FROM (SELECT DISTINCT log_name FROM new_rows) s;
+  RETURN NULL;
+END;
+$fn$;
+
+CREATE OR REPLACE TRIGGER event_log_notify_trg
+  AFTER INSERT ON event_log
+  REFERENCING NEW TABLE AS new_rows
+  FOR EACH STATEMENT EXECUTE FUNCTION event_log_notify();
+"
+
+let functionStatements = [dcbConditionWhereFn, dcbAppendFn, eventLogNotifyFn]
 
 let ensureSchema = async (pool: PgDriver.pool): unit => {
   for i in 0 to tableStatements->Array.length - 1 {
@@ -251,6 +285,6 @@ let ensureSchema = async (pool: PgDriver.pool): unit => {
 // Mirrors the reventless-local contract that reset wipes data, not structure.
 let truncateAll = async (pool: PgDriver.pool): unit => {
   await pool->PgDriver.exec(
-    "TRUNCATE event_log, snapshot, dcb_event, dcb_scope, dcb_subscription RESTART IDENTITY",
+    "TRUNCATE event_log, snapshot, dcb_event, dcb_scope, dcb_subscription, event_log_subscription RESTART IDENTITY",
   )
 }

package/lib/ocaml/PostgresIntegrationTest.res

@@ -233,4 +233,72 @@ switch processEnv->Dict.get("PG_URL") {
       expect(again)->toBe(0)
     })
   })
+
+  describe("classic change feed (event_log, B2.5)", () => {
+    testPromise("drains classic events in commit order, with fields, then checkpoints", async () => {
+      let (_n, ops, _s) = EventLogStorage_Postgres.makeStorage(~pool, ~name="cf-orders", ~opts)
+      let _ = await ops.append(0, "agg-1", [evJson("m0", 1), evJson("m1", 2)])
+      let _ = await ops.append(0, "agg-2", [evJson("m2", 3)])
+
+      let collected = ref([])
+      let processed = await EventLogChangeFeed.drain(
+        pool,
+        ~logName="cf-orders",
+        ~subscriber="cf-sub",
+        ~handle=async evs => collected := collected.contents->Array.concat(evs),
+      )
+      expect(processed)->toBe(3)
+      expect(collected.contents->Array.length)->toBe(3)
+
+      // Fields round-trip from the stored row.
+      let first = collected.contents->Array.getUnsafe(0)
+      expect(first.aggregateId)->toBe("agg-1")
+      expect(first.seqNr)->toBe(0)
+      expect(first.msgId)->toEqual(Some("m0"))
+
+      // Cursors are strictly increasing in drain order.
+      let cursors = collected.contents->Array.map(e => e.cursor)
+      let increasing = ref(true)
+      for i in 1 to cursors->Array.length - 1 {
+        if cursors->Array.getUnsafe(i) <= cursors->Array.getUnsafe(i - 1) {
+          increasing := false
+        }
+      }
+      expect(increasing.contents)->toBe(true)
+
+      // Second drain from the saved checkpoint sees nothing new.
+      let again = await EventLogChangeFeed.drain(
+        pool,
+        ~logName="cf-orders",
+        ~subscriber="cf-sub",
+        ~handle=async _ => (),
+      )
+      expect(again)->toBe(0)
+    })
+
+    testPromise("concurrent appends across aggregates: every event drained exactly once", async () => {
+      let (_n, ops, _s) = EventLogStorage_Postgres.makeStorage(~pool, ~name="cf-concurrent", ~opts)
+      let n = 20
+      // One event per aggregate, all dispatched before awaiting — genuinely
+      // concurrent on the pool, so global_seq is assigned in interleaved/undefined
+      // commit order. The xmin fence must still drain every event exactly once.
+      let promises =
+        Array.make(~length=n, 0)->Array.mapWithIndex((_, i) =>
+          ops.append(0, "agg-" ++ Int.toString(i), [evJson("m" ++ Int.toString(i), i)])
+        )
+      let _ = await Promise.all(promises)
+
+      let collected = ref([])
+      let _ = await EventLogChangeFeed.drain(
+        pool,
+        ~logName="cf-concurrent",
+        ~subscriber="cf-conc-sub",
+        ~handle=async evs => collected := collected.contents->Array.concat(evs),
+      )
+      // No skips: all N events present. No dupes: N distinct cursors.
+      expect(collected.contents->Array.length)->toBe(n)
+      let distinctCursors = collected.contents->Array.map(e => e.cursor)->Set.fromArray
+      expect(distinctCursors->Set.size)->toBe(n)
+    })
+  })
 }

package/lib/ocaml/ReventlessPostgres.mlmap

@@ -1,5 +1,6 @@
 randjbuildsystem
 DcbEventLogStorage_Postgres
+EventLogChangeFeed
 EventLogStorage_Postgres
 PgChangeFeed
 PgDriver

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-postgres",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.4",
   "description": "Postgres storage backend for Reventless (classic + DCB event logs, query DB, change feed). Connection-string only — RDS/Aurora, any managed provider, or a local container.",
   "license": "Apache-2.0",
   "jest": {
@@ -24,16 +24,16 @@
     "sury": "11.0.0-alpha.4",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.24",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.140",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.142",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.5",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.86",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.64"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.88",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.66"
   },
   "devDependencies": {
     "@types/pg": "^8.11.10",
     "rescript": "^12.3.0",
     "sury-ppx": "11.0.0-alpha.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.50"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.51"
   },
   "peerDependencies": {
     "rescript": "^12.3.0"

package/src/EventLogChangeFeed.res

@@ -0,0 +1,184 @@
+// Classic `event_log` change feed (B2.5) — the aggregate-path analogue of
+// `PgChangeFeed` (which serves the DCB `dcb_event` log).
+//
+// Like the DCB feed this is NOT logical decoding: classic events are already
+// durably queryable in-table, so the feed is an xmin-fenced read over `event_log`
+// plus an `event_log_subscription` checkpoint. A statement-level AFTER INSERT
+// trigger (`event_log_notify`, see PgSchema) issues `pg_notify('evlog_<log>')`,
+// turning polling into near-real-time wakeup; a low-frequency fallback tick in the
+// consumer covers missed notifications.
+//
+// Cursor semantics mirror the DCB feed exactly: the opaque `<xid8>:<global_seq>`
+// string (zero-padded so string order == numeric order). Reads apply the xmin
+// barrier (`transaction_id < pg_snapshot_xmin(pg_current_snapshot())`), so a
+// returned cursor is stable forever — an event committed late (lower global_seq,
+// later commit) is never skipped by a checkpointing reader. `global_seq` alone,
+// being an IDENTITY assigned at INSERT, could NOT provide that guarantee.
+
+// Reuse the shared `<a>:<b>` cursor codec from the DCB storage — identical format.
+module Dcb = DcbEventLogStorage_Postgres
+
+// One classic event as the feed surfaces it. `payload` is the stored event JSON
+// verbatim; a bus/topic relay transforms it into its target shape (e.g. the AWS
+// EventCollector `{id, meta, event}` body) — that transform is not this package's
+// concern.
+type classicEvent = {
+  cursor: string,
+  aggregateId: string,
+  seqNr: int,
+  payload: JSON.t,
+  msgId: option<string>,
+}
+
+// One page of the feed. `events` are in (transaction_id, global_seq) order;
+// `cursor` is the checkpoint to persist and to pass as the next `after` (None when
+// the page was empty — nothing new).
+type batch = {
+  events: array<classicEvent>,
+  cursor: option<string>,
+}
+
+let selectColumns = "
+  lpad(transaction_id::text, 20, '0') || ':' || lpad(global_seq::text, 20, '0') AS cursor,
+  aggregate_id,
+  seq_nr,
+  payload,
+  msg_id
+"
+
+let coerceInt = (v: JSON.t): int =>
+  switch v {
+  | JSON.Number(n) => Float.toInt(n)
+  | JSON.String(s) => s->Int.fromString->Option.getOr(0)
+  | _ => 0
+  }
+
+let rowToEvent = (row: dict<JSON.t>): classicEvent => {
+  let str = key =>
+    switch row->Dict.get(key) {
+    | Some(JSON.String(s)) => s
+    | _ => ""
+    }
+  {
+    cursor: str("cursor"),
+    aggregateId: str("aggregate_id"),
+    seqNr: row->Dict.get("seq_nr")->Option.map(coerceInt)->Option.getOr(0),
+    payload: row->Dict.get("payload")->Option.getOr(JSON.Encode.null),
+    msgId: switch row->Dict.get("msg_id") {
+    | Some(JSON.String(s)) => Some(s)
+    | _ => None
+    },
+  }
+}
+
+// Read up to `limit` events after `after` (the xmin-fenced feed query — whole log).
+// Returns the events and the cursor of the last one.
+let readBatch = async (
+  pool: PgDriver.pool,
+  ~logName: string,
+  ~after: option<string>=?,
+  ~limit: int=500,
+): batch => {
+  let params = [JSON.Encode.string(logName)]
+  let where = ref("log_name = $1 AND transaction_id < pg_snapshot_xmin(pg_current_snapshot())")
+  switch after->Option.flatMap(Dcb.decodeCursor) {
+  | Some((tx, pos)) =>
+    // $2 = tx (referenced twice), $3 = global_seq.
+    params->Array.push(JSON.Encode.string(tx))
+    params->Array.push(JSON.Encode.string(pos))
+    where :=
+      where.contents ++
+      " AND (transaction_id > $2::xid8 OR (transaction_id = $2::xid8 AND global_seq > $3::bigint))"
+  | None => ()
+  }
+  let sql = `SELECT ${selectColumns} FROM event_log WHERE ${where.contents} ORDER BY transaction_id ASC, global_seq ASC LIMIT ${Int.toString(limit)}`
+  let rows = await pool->PgDriver.query(sql, params)
+  let events = rows->Array.map(rowToEvent)
+  let cursor = switch events->Array.get(events->Array.length - 1) {
+  | Some(last) => Some(last.cursor)
+  | None => None
+  }
+  {events, cursor}
+}
+
+// --- Checkpoint contract (event_log_subscription) ---
+
+// The persisted checkpoint for `subscriber`, encoded as a cursor, or None if the
+// subscriber has never committed (→ replay from the beginning).
+let loadCheckpoint = async (pool: PgDriver.pool, ~subscriber: string): option<string> =>
+  switch await pool->PgDriver.queryOne(
+    "SELECT lpad(last_tx::text, 20, '0') || ':' || lpad(last_global_seq::text, 20, '0') AS cursor
+       FROM event_log_subscription WHERE subscriber = $1 AND last_global_seq > 0",
+    [JSON.Encode.string(subscriber)],
+  ) {
+  | Some(row) =>
+    switch row->Dict.get("cursor") {
+    | Some(JSON.String(s)) => Some(s)
+    | _ => None
+    }
+  | None => None
+  }
+
+// Persist the checkpoint. Idempotent upsert; decodes the cursor to its two columns
+// so a later `loadCheckpoint` round-trips exactly.
+let saveCheckpoint = async (pool: PgDriver.pool, ~subscriber: string, ~cursor: string): unit =>
+  switch Dcb.decodeCursor(cursor) {
+  | Some((tx, pos)) =>
+    let _ = await pool->PgDriver.query(
+      "INSERT INTO event_log_subscription(subscriber, last_tx, last_global_seq)
+       VALUES ($1, $2::xid8, $3::bigint)
+       ON CONFLICT (subscriber)
+       DO UPDATE SET last_tx = EXCLUDED.last_tx, last_global_seq = EXCLUDED.last_global_seq",
+      [JSON.Encode.string(subscriber), JSON.Encode.string(tx), JSON.Encode.string(pos)],
+    )
+  | None => ()
+  }
+
+// --- Wakeup ---
+
+// LISTEN on `evlog_<logName>`; `onWake` fires on every notification. Returns the
+// dedicated client (caller owns it — release via unlisten). Pair with a
+// low-frequency fallback tick so a missed NOTIFY only adds latency, never a stall.
+let listen = (pool: PgDriver.pool, ~logName: string, ~onWake: unit => unit): promise<
+  PgDriver.client,
+> => pool->PgDriver.listen(~channel="evlog_" ++ logName, ~onNotify=_ => onWake())
+
+let unlisten = (client: PgDriver.client, ~logName: string): promise<unit> =>
+  client->PgDriver.unlisten(~channel="evlog_" ++ logName)
+
+// --- Reference consumer driver ---
+
+// Drain the feed for `subscriber` from its checkpoint: repeatedly readBatch →
+// `handle` the events → saveCheckpoint, until a short page. `handle` must be
+// idempotent (a crash between handle and checkpoint replays the last batch).
+// Returns the number of events processed.
+let drain = async (
+  pool: PgDriver.pool,
+  ~logName: string,
+  ~subscriber: string,
+  ~limit: int=500,
+  ~handle: array<classicEvent> => promise<unit>,
+): int => {
+  let processed = ref(0)
+  let cursor = ref(await loadCheckpoint(pool, ~subscriber))
+  let continue = ref(true)
+  while continue.contents {
+    let {events, cursor: newCursor} = await readBatch(pool, ~logName, ~after=?cursor.contents, ~limit)
+    if events->Array.length == 0 {
+      continue := false
+    } else {
+      await handle(events)
+      switch newCursor {
+      | Some(c) =>
+        await saveCheckpoint(pool, ~subscriber, ~cursor=c)
+        cursor := Some(c)
+      | None => ()
+      }
+      processed := processed.contents + events->Array.length
+      if events->Array.length < limit {
+        continue := false
+      }
+    }
+  }
+  processed.contents
+}