@rig-c/core 2.83.0 → 2.84.0

package/docs/AUTHORING.md

@@ -9186,7 +9186,7 @@ inside it, and a second copy of the leg on the same bone):
 bun cli.ts render --candidate path/to/spine --animation swing --seam skirt:leg,leg_front:leg [--skin …] [--fps 12]
 # rigc render
 # One seam line per pair, including no gap/no ghost or SKIP, followed by
-# exposure "<slot>" for each named member: frames, worst cell count and box.
+# exposure "<slot>" and joint contact: joined/separated/unavailable frames.
 ```
 
 The skirt swinging off the leg opens background between the leg's right edge and
@@ -9241,6 +9241,33 @@ table's vertices, and the atlas alpha:
   The rectangle controls derive eight real tear cells; a notched branch derives
   sixteen adjacent background cells excluded by this rule, including when both
   kinds occur in the same frame.
+- **jointContact** — a separate observation of **pair material connectivity**,
+  on that same half-opacity texel grid. It requires a setup band and exactly
+  one nonempty edge-connected material component for each named drawing, at
+  both setup and frame. `joined` means the two posed components overlap or
+  share a cell edge; `separated` means their union is disconnected. Sharing
+  only a corner is not edge contact. Every sampled frame is present, including
+  `unavailable` with a reason when a member is absent, the setup band is empty,
+  material is empty or has multiple islands, or a named slot draws multiple
+  fragments. No samples yields an empty list, not a successful observation.
+
+  **Raw gap measures swept support, not certified tearing.** An attached limb
+  can rotate well away from its parent and leave an external crescent of
+  background inside that support: `gap` can be positive while `jointContact`
+  is `joined`. Removing enough proximal material can leave initial overlap but
+  disconnect the same two drawings under the same attachment maps; that is
+  operational material separation, reported as `separated`. This uses no pivot
+  radius, anatomical assumption or new opacity threshold. The synthetic
+  rectangular controls use an independent endpoint set oracle and actual gated
+  builds rendered through both posers.
+
+  Contact does **not** infer anatomical joint intent. A joined pair can have a
+  local notch or hole, including a genuine local tear while other material
+  remains connected; contact cannot classify individual gap cells as harmless
+  background or tearing. A separated pair need not be artistically wrong and
+  can have zero raw gap outside the existing swept support. The grid cannot
+  resolve sub-cell contact. Other skeleton drawings and draw order do not
+  enter this pair-material observation. `unavailable` is never zero or PASS.
 - **ghost** — a cell one piece draws at the frame and the other does not, which
   the drawing piece, carrying it back, lands in the band, and which the other,
   carrying it back, finds neither drawing at the setup pose: the overlap swung
@@ -9336,6 +9363,7 @@ block carries the definitions above in words.
 | `pairs[].ghostA`, `pairs[].ghostB` | object | — | the same `{ frames, spans, worst }` shape for ghost cells drawn by `a` only and `b` only; an empty owner has `frames: []`, `spans: []`, `worst: null` |
 | `pairs[].gapOpen`, `pairs[].gapCovered` | object | — | the same `{ frames, spans, worst }` shape for gap cells with zero or positive rendered skeleton-composite alpha, respectively; an empty kind has `frames: []`, `spans: []`, `worst: null` |
 | `pairs[].exposureA`, `pairs[].exposureB` | object | — | `{ frames, spans, worst }` for the whole named slot’s positive-alpha cells on otherwise zero-alpha skeleton background; measured independently of the band, including SKIP pairs; not part of `opens` or `maxPx` |
+| `pairs[].jointContact.frames[]` | object | seconds for `time` | `{ index, time, status, reason }` for every sampled frame; `status` is `joined`, `separated` or `unavailable`; `reason` is `null` for measured contact and a named explanation for unavailable contact. Independent of raw gap/ghost, `opens` and `maxPx` |
 | `<kind>.frames[]` | hit[] | — | only the frames with a cell of that kind, in frame order |
 | `<kind>.spans[]` | array | — | `<kind>.frames` as runs of consecutive indices: `{ frames: [first, last], times: [first, last], maxPx }` — frame indices, seconds, px |
 | `<kind>.worst` | hit or `null` | — | the frame with the most cells, the earliest on a tie; `null` when none |
@@ -9362,6 +9390,18 @@ Clean stationary/shared-motion pair fields remain unchanged apart from exposure;
 the `reading` legend states the revised definitions. Historical measurements
 above pin their old reader and must not be treated as current measurements.
 
+The subsequent `jointContact` addition preserves **all** existing pair fields,
+raw gap/coverage/ghost/exposure numbers, `opens`, `maxPx` and their definitions.
+It appends one pair field, a legend entry and a contact clause to the printed
+line; `rigc-seam/1` is unchanged. Readers accepting additive keys can keep their
+existing policy. In particular, a consumer using raw `gapOpen` plus an owned
+ghost as its policy still uses those same numbers; adding contact does not
+change that verdict. Adopting material contact as a separate consumer policy
+requires an explicit choice. Readers comparing entire JSON objects or exact
+console lines must account for the added fields and clause. `stays closed` and
+`opens` in the existing clause continue to describe raw gap/ghost; use the
+separate contact clause for operational material separation.
+
 **Refused, nothing written:** a slot the skeleton does not have (with the slots it
 does), an entry without exactly one `:`, an empty entry or name, a slot paired with
 itself (a seam is between two drawings), a pair named twice in either order (the
@@ -12577,7 +12617,7 @@ pixel (`IN09`).
 | What does this bone move? | `--show art,mesh,weights:<bone> --dim` | the bone's weight over every region and mesh it moves, as a heat: a pixel whose centre lies in a triangle is painted the ramp's colour at the blend of its corners' weights — blue near 0, yellow at 0.5, red at 1 (the stops are in the legend) — and a weight of 0 is not painted, so the art shows where the bone does not reach. A region and an unweighted mesh are moved whole by their slot's bone. The weights are read off `skeleton.json`, the file both posers skin from; a bone that weights nothing paints nothing and the run says so on a line of its own |
 | Does this part's edge follow that bone? | `--show art,weights:<bone>,mesh --overlay-slot <part> --zoom slot:<part>` | the part's own triangles and the bone's weight over them alone, over the whole painting. Where slots stack — a neck under the face, the hair, a collar — every mesh crossing the box is drawn and the heat is the union of every slot the bone moves, so the part's edge has no pixel of its own until the others are left out. The legend's `meshes[]` gives the part's weight for the bone at every vertex, so "does the top row follow the head" is read as numbers as well as colour |
 | Is this rig's density where its motion is? | `--show art,density --dim` | each region and mesh filled by its **ratio** — its triangles per world unit² over the figure's — on one ramp, log-scaled and centred on 1×: grey is as dense as the figure, pink to magenta denser (4×, 16×), light to dark green sparser (1/4×, 1/16×), clamped past the end stops (the stops are in the legend). A part's area is its posed mesh's own, the sum of its triangles' areas at the pose drawn, not the image's box; a region is two triangles over its quad. Where parts overlap the pixel is the part drawn last, as in the art, so a part under others is read with `--overlay-slot <part>`. The figure's totals are always over every slot the pose shows — the filter picks what is drawn and listed, never what the figure is — and the legend's `density` gives each slot's attachment, kind, vertices, triangles, hull, area, triangles per area, ratio and the bones it is weighted to, in draw order. A measurement, not a verdict: no bar is drawn, and `A13_MESH_BUDGET` stays the one gate on counts |
-| Does a joint tear in this animation? | `render --seam <a>:<b> --animation <name>` (§8.8) | One line per pair: the frames where background opens inside the joint (gap) or the overlap band of one piece shows past its partner (ghost), with the worst frame's cell count and world box; `seam.json` carries every frame and its time, and the runs of frames. A pair whose drawings never overlap is a SKIP, said by name. A reading, not a verdict — the exit status never moves |
+| Does a pair lose material contact in this animation? | `render --seam <a>:<b> --animation <name>` (§8.8) | Raw swept-support gap and visible ghost counts, plus separate pair material contact: joined, separated or explicitly unavailable. Gap alone is not certified tearing; contact does not infer anatomical intent or rule out local notches. `seam.json` records the frames and times. A reading, not a verdict — the exit status never moves |
 | Which slot covers which in this animation? | `render --overlaps --animation <name>` (§8.9) | One `OVERLAP "<under>" under "<over>"` line per pair that moves: the frames it covers on, as runs, and the most pixels it covers and the frame of them; one line counting the layering the motion does not move. `overlaps.json` carries every frame's pairs with their pixel count and box, and `overlaps-f<NNNN>.png` draws each covered frame's contours, the covered part dashed. A reading, not a verdict — the draw-order key is the remedy |
 | Does anything fold in this animation? | `render --folds --animation <name>` (§8.3), then `inspect --show art,folds,mesh --animation <name> --at <the worst frame's time> --zoom folds` | `render --folds` prints one line per mesh with a triangle turned over against the setup pose: the frames, the worst frame's count, which triangles, their world box at that frame and their setup-pose area. The view fills those triangles at the pose drawn — every pixel whose centre a folded triangle holds — in the colour the legend's `folds` states, and the legend's `folds[]` names, per mesh, the folded triangles by index with the same box and area, and the setup pose's degenerate and inverted ones, which are never counted. A fold is usually a sliver a few units across, invisible in a picture of the whole mesh: `--zoom folds` frames the picture to the folded triangles' box. A thin sliver still needs pixels — raise `--max` when the fill is a line. A reading, not a verdict |
 | How is this part triangulated? | `--show art,mesh,hull --zoom slot:<slot>` | each mesh's triangle edges, and over them its hull — vertex 0 to 1 to … to `hull − 1` and back. Regions are not drawn: a region is not a mesh. The legend lists every vertex in world units and in pixels |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/core",
-  "version": "2.83.0",
+  "version": "2.84.0",
   "description": "AI-authored 2D rigging and animation, verified before it is written. rigc compiles a rig spec into skeleton data in the Spine 4.3 format, gates it with named assertions held to a spine-core round trip's verdicts, and emits nothing that fails. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/cli/shared.ts

@@ -1073,7 +1073,7 @@ const FLAG_MEANINGS: Record<string, string> = {
     'per pair, the frames with a gap — background inside the carried overlap hull and a local sweep of the same setup band cell through both drawings — ' +
     'and the frames with a visible ghost after draw order — the band of one drawing showing where, from its partner\'s point of view, nothing was drawn at the setup pose — each with ' +
     `its cell count, area and world box. Cells are one texel of the coarser drawing, drawn at ${DRAWN_ALPHA} of 255 or more. One line per pair; a pair whose ` +
-    'drawings share no cell at the setup pose is a SKIP. exposureA/B count each named slot’s positive-alpha cells on otherwise empty skeleton background, even without a band or partner. A reading, not a gate: the exit status never moves. An unknown slot, a slot with itself, ' +
+    'drawings share no cell at the setup pose is a SKIP. Raw gap measures swept support, not certified tearing. jointContact separately reports pair material connectivity: joined, separated, or unavailable with a reason; it does not infer anatomical joint intent or rule out local notches. exposureA/B count each named slot’s positive-alpha cells on otherwise empty skeleton background, even without a band or partner. A reading, not a gate: the exit status never moves. An unknown slot, a slot with itself, ' +
     'a slot that draws on no frame, a malformed list and a pair named twice in either order are refused by name. Not with --slot/--hide',
   'angle-range':
     'also read, for each <bone>:<relative-to> pair, the range of the first bone\'s world direction against the second\'s over each set\'s ' +

package/src/seam.ts

@@ -63,6 +63,13 @@
  * Shared transforms read closed. The outer-hull reach remains bounded: tears
  * outside the transported setup overlap are not certified absent by a zero.
  *
+ * `jointContact` separately observes material connectivity on that same grid.
+ * Initially overlapping, single-component drawings are joined if their posed
+ * union is edge-connected, separated otherwise. Missing bands or non-single
+ * components are unavailable. Joined does not rule out local holes or notches;
+ * separated does not infer artistic intent. Raw gap can include an external
+ * rotational crescent of a joined pair and is deliberately unchanged.
+ *
  * Pure: no clock, no randomness, no runtime. The pieces, the attachments and the
  * rest table are handed in by whichever poser drew the frames.
  */
@@ -159,6 +166,15 @@ export interface SeamKindReading {
   worst: SeamHit | null;
 }
 
+/** Connectivity of two initially overlapping single material components, at grid resolution. */
+export interface SeamContactFrame {
+  index: number;
+  time: number;
+  status: 'joined' | 'separated' | 'unavailable';
+  /** Non-null exactly when the observation is unavailable; never a measured zero. */
+  reason: string | null;
+}
+
 /** One pair's reading over one frame set. */
 export interface SeamPairReading {
   a: string;
@@ -186,6 +202,8 @@ export interface SeamPairReading {
   /** Positive-alpha cells contributed by the named slot where all OTHER slots have zero alpha. Independent of the band. */
   exposureA: SeamKindReading;
   exposureB: SeamKindReading;
+  /** Every sampled frame, including unavailable frames. Independent of raw gap/ghost and their summaries. */
+  jointContact: { frames: SeamContactFrame[] };
 }
 
 /** `seam.json`: one frame set's reading, every pair the flag names, in the flag's order. */
@@ -196,7 +214,7 @@ export interface SeamFile {
   skin?: string;
   fps: number;
   /** What the numbers mean, stated in the file so a reader does not need this module. */
-  reading: { read: string; cell: string; drawn: string; band: string; carried: string; gap: string; ghost: string; box: string; status: string; ghostA: string; ghostB: string; gapOpen: string; gapCovered: string; exposureA: string; exposureB: string };
+  reading: { read: string; cell: string; drawn: string; band: string; carried: string; gap: string; ghost: string; box: string; status: string; ghostA: string; ghostB: string; gapOpen: string; gapCovered: string; exposureA: string; exposureB: string; jointContact: string };
   pairs: SeamPairReading[];
 }
 
@@ -219,6 +237,8 @@ export interface SeamPlant {
   hiddenGhost?: boolean;
   /** Bridge unrelated overlap cells with the old global hull. */
   globalHull?: boolean;
+  /** Force a measured contact to one answer, ignoring the rendered material. */
+  contact?: 'joined' | 'separated';
   /** Wrong composite readings: half opacity, only the pair, or every gap forced to one kind. */
   gapCoverage?: 'half' | 'pair' | 'open' | 'covered';
   /** Report a pair with no band as read, rather than as a SKIP. */
@@ -473,8 +493,44 @@ function markHull(hull: ReadonlyArray<[number, number]>, grid: Grid, cells: Uint
   }
 }
 
+/** Count edge-connected components, stopping after the second: only exactly one is supported. */
+function components(cells: Uint8Array, width: number): number {
+  const seen = new Uint8Array(cells.length);
+  const queue = new Int32Array(cells.length);
+  let count = 0;
+  for (let k = 0; k < cells.length; k++) {
+    if (!cells[k] || seen[k]) continue;
+    if (++count === 2) return count;
+    let head = 0, tail = 1;
+    queue[0] = k; seen[k] = 1;
+    while (head < tail) {
+      const i = queue[head++];
+      const visit = (j: number): void => {
+        if (j >= 0 && j < cells.length && cells[j] && !seen[j]) { seen[j] = 1; queue[tail++] = j; }
+      };
+      if (i % width > 0) visit(i - 1);
+      if (i % width < width - 1) visit(i + 1);
+      visit(i - width); visit(i + width);
+    }
+  }
+  return count;
+}
+
+type Contact = Pick<SeamContactFrame, 'status' | 'reason'>;
+const unavailableContact = (reason: string): Contact => ({ status: 'unavailable', reason });
+
+/** Four neighbours mean a shared cell edge; diagonals alone do not connect material. No distance parameter. */
+function contactOf(restA: Uint8Array, restB: Uint8Array, drawnA: Uint8Array, drawnB: Uint8Array, width: number, plant: SeamPlant): Contact {
+  for (const [name, cells] of [['a setup', restA], ['b setup', restB], ['a frame', drawnA], ['b frame', drawnB]] as const) {
+    const n = components(cells, width);
+    if (n !== 1) return unavailableContact(`${name}: ${n === 0 ? 'no' : 'multiple'} edge-connected half-opacity material components; exactly one is required`);
+  }
+  const union = drawnA.map((v, k) => v || drawnB[k]);
+  return { status: plant.contact ?? (components(union, width) === 1 ? 'joined' : 'separated'), reason: null };
+}
+
 /** One frame's counts, or `null` when the two drawings share no cell at the setup pose. See the module comment. */
-function readFrame(A: Side, B: Side, cell: number, plant: SeamPlant, frame: SeamFrame, pages: ReadonlyMap<string, Plate>, grid: Grid, visibility: readonly Uint8Array[]): { gap: Cells; ghost: Cells; ghostA: Cells; ghostB: Cells; gapOpen: Cells; gapCovered: Cells } | null {
+function readFrame(A: Side, B: Side, cell: number, plant: SeamPlant, frame: SeamFrame, pages: ReadonlyMap<string, Plate>, grid: Grid, visibility: readonly Uint8Array[]): { gap: Cells; ghost: Cells; ghostA: Cells; ghostB: Cells; gapOpen: Cells; gapCovered: Cells; contact: Contact } | null {
   const { width, height } = grid.viewport;
   const restA = restPiece(A);
   const restB = restPiece(B);
@@ -520,6 +576,7 @@ function readFrame(A: Side, B: Side, cell: number, plant: SeamPlant, frame: Seam
   const hull = hullOf(carried);
   const drawnA = drawnCells(A.piece, A.page, grid.viewport);
   const drawnB = drawnCells(B.piece, B.page, grid.viewport);
+  const contact = contactOf(bandA, bandB, drawnA, drawnB, width, plant);
   const [visibleA, visibleB] = visibility;
   const posedIdsA = triangleIds(A.triangles, A.piece.world, grid);
   const posedIdsB = triangleIds(B.triangles, B.piece.world, grid);
@@ -536,7 +593,7 @@ function readFrame(A: Side, B: Side, cell: number, plant: SeamPlant, frame: Seam
   const gapCovered: Cells = { px: 0, box: null };
   let alphaCells: Uint8Array | null = null;
   const take = (into: Cells, qx: number, qy: number): void => takeCell(into, qx, qy, cell);
-  if (plant.never) return { gap, ghost, ghostA, ghostB, gapOpen, gapCovered };
+  if (plant.never) return { gap, ghost, ghostA, ghostB, gapOpen, gapCovered, contact };
   const inBand = (p: [number, number] | null): boolean => p !== null && p[0] >= bx0 - cell / 2 && p[0] <= bx1 + cell / 2 && p[1] >= by0 - cell / 2 && p[1] <= by1 + cell / 2;
   for (let py = 0; py < height; py++) {
     for (let px = 0; px < width; px++) {
@@ -570,7 +627,7 @@ function readFrame(A: Side, B: Side, cell: number, plant: SeamPlant, frame: Seam
       }
     }
   }
-  return { gap, ghost, ghostA, ghostB, gapOpen, gapCovered };
+  return { gap, ghost, ghostA, ghostB, gapOpen, gapCovered, contact };
 }
 
 const restKey = (slot: string, attachment: string): string => `${slot}\u0000${attachment}`;
@@ -634,9 +691,12 @@ export function seamsOf(
     const openGaps: SeamHit[] = [];
     const coveredGaps: SeamHit[] = [];
     const exposuresA: SeamHit[] = [], exposuresB: SeamHit[] = [];
+    const contacts: SeamContactFrame[] = [];
     for (const frame of frames) {
       const A = sideOf(frame, a);
       const B = sideOf(frame, b);
+      const contact = (reading: Contact): void => { contacts.push({ index: frame.index, time: frame.time, ...reading }); };
+      if (A === null || B === null) contact(unavailableContact('both named slots must draw on this frame'));
       const sides = [A, B].filter((side): side is Side => side !== null);
       if (sides.length === 0) continue;
       const sizes = sides.map((side) => texelSize(side.piece, side.rest, side.page));
@@ -652,7 +712,9 @@ export function seamsOf(
       drawn++;
       const cell = exposureCell;
       const read = readFrame(A, B, cell, plant, frame, pages, exposureGrid, exposure.map((m) => m.visible));
-      if (read === null) continue;
+      if (read === null) { contact(unavailableContact('no shared half-opacity cell at the setup pose; no band to identify a joint')); continue; }
+      const fragmented = [a, b].some(slot => frame.pieces.filter(p => p.slot === slot).length !== 1);
+      contact(fragmented ? unavailableContact('each named slot must draw exactly one fragment for material contact') : read.contact);
       banded++;
       for (const [cells, into] of [[read.gap, gaps], [read.ghost, ghosts], [read.ghostA, ghostsA], [read.ghostB, ghostsB], [read.gapOpen, openGaps], [read.gapCovered, coveredGaps]] as const) {
         if (cells.px > 0 && cells.box !== null) into.push({ index: frame.index, time: frame.time, px: cells.px, cell, area: cells.px * cell * cell, box: cells.box });
@@ -663,7 +725,7 @@ export function seamsOf(
     const opens = [...new Set([...gaps, ...ghosts].map((f) => f.index))].sort((x, y) => x - y);
     const maxPx = Math.max(0, ...gaps.map((f) => f.px), ...ghosts.map((f) => f.px));
     const status = banded === 0 && !plant.skipAsRead ? 'skip' : 'read';
-    return { a, b, drawn, banded, status, opens, maxPx, gap, ghost, ghostA: kindOf(ghostsA), ghostB: kindOf(ghostsB), gapOpen: kindOf(openGaps), gapCovered: kindOf(coveredGaps), exposureA: kindOf(exposuresA), exposureB: kindOf(exposuresB) };
+    return { a, b, drawn, banded, status, opens, maxPx, gap, ghost, ghostA: kindOf(ghostsA), ghostB: kindOf(ghostsB), gapOpen: kindOf(openGaps), gapCovered: kindOf(coveredGaps), exposureA: kindOf(exposuresA), exposureB: kindOf(exposuresB), jointContact: { frames: contacts } };
   });
 }
 
@@ -685,6 +747,7 @@ export const SEAM_READING: SeamFile['reading'] = {
   exposureA: 'positive-rendered-alpha cells from named slot a where removing every fragment of that slot leaves alpha 0 from all other skeleton slots, regardless of draw order; measured over the whole drawing even without a seam band or partner; same hit, span and worst units as gap',
   exposureB: 'the same background exposure for named slot b; swapping the pair exchanges exposureA and exposureB; exposure does not enter opens or maxPx and is not a change-from-setup measurement',
   gapCovered: 'the gap cells whose centre has positive rendered alpha from any skeleton drawing, including the pair; alpha 1..127 covers too — this is not the pair\'s half-opacity test, and no presentation background enters',
+  jointContact: 'every sampled frame: joined or separated only when a setup band exists and each named drawing has exactly one edge-connected half-opacity material component at setup and frame; joined means their frame union is edge-connected (overlap or shared cell edge), separated means it is not; diagonal contact alone is separated. Otherwise unavailable with a reason, including multiple fragments of a named slot. Uses the existing origin-aligned texel grid, alpha and attachment maps, independent of other slots and draw order. Raw gap measures swept support, not certified tearing. Contact is pair material connectivity, not anatomical joint intent; joined does not rule out local holes/notches. No statement about sub-cell contact; raw gap/ghost, opens/maxPx and exit status are unchanged',
 };
 
 /** The file for one frame set. */
@@ -730,5 +793,12 @@ function seamSummary(animation: string | null, fps: number, pair: SeamPairReadin
 
 /** The seam summary plus whole-drawing background exposures, including on SKIP pairs. */
 export function seamLine(animation: string | null, fps: number, pair: SeamPairReading): string {
-  return `${seamSummary(animation, fps, pair)}; ${kindText(`exposure ${JSON.stringify(pair.a)}`, pair.exposureA)}; ${kindText(`exposure ${JSON.stringify(pair.b)}`, pair.exposureB)}`;
+  const contacts = pair.jointContact.frames;
+  const contactText = contacts.length === 0 ? 'unavailable: no sampled frames' : null;
+  const summary = (status: SeamContactFrame['status']): string => {
+    const frames = contacts.filter(f => f.status === status);
+    return `${status} on ${frames.length} frame(s) [${indexRuns(frames.map(f => f.index))}]`;
+  };
+  const reasons = [...new Set(contacts.flatMap(f => f.reason === null ? [] : [f.reason]))];
+  return `${seamSummary(animation, fps, pair)}; ${kindText(`exposure ${JSON.stringify(pair.a)}`, pair.exposureA)}; ${kindText(`exposure ${JSON.stringify(pair.b)}`, pair.exposureB)}; joint contact: ${contactText ?? `${summary('joined')}, ${summary('separated')}, ${summary('unavailable')}`}${reasons.length ? ` (${reasons.join('; ')})` : ''}`;
 }