react-native-roster 0.0.0 → 0.1.0

package/src/adapters/rrule/occurrences.ts

@@ -0,0 +1,288 @@
+import type * as RRuleModule from 'rrule-temporal' with { 'resolution-mode': 'import' };
+import type * as Spec from 'temporal-spec' with { 'resolution-mode': 'import' };
+import type { Weekday, Window } from '../../core';
+import type { Occurrences } from './cache';
+import type { RosterDate, RosterRule } from './types';
+
+// 1.6.0 is an ES module package with a CommonJS build under its require condition
+// and declarations resolved under import. Keep its actual types while selecting
+// the require export for our CJS build and Metro source entry.
+const { allowedWeekdays, RRuleTemporal } = require('rrule-temporal') as typeof RRuleModule;
+// Both engines must use the same polyfill export; mixed import/require copies
+// fail the recurrence engine's ZonedDateTime instanceof check.
+const { Temporal } = require('@js-temporal/polyfill') as { Temporal: typeof Spec.Temporal };
+
+type RuleDateTime = Spec.Temporal.PlainDateTime | Spec.Temporal.ZonedDateTime;
+
+export function enumerate(
+  input: RosterRule | RosterDate,
+  envelope: Window,
+  cap: number,
+  // Internal reference path for testing against original-anchor enumeration.
+  advanceAnchor = true,
+): Occurrences {
+  const result: Occurrences = { spans: [], capped: false };
+  const admit = (date: Spec.Temporal.PlainDate): boolean => {
+    const span = hoursFor(date, input);
+    if (span.start >= envelope.end || span.end <= envelope.start || span.start >= span.end)
+      return true;
+    if (result.spans.length === cap) {
+      result.capped = true;
+      return false;
+    }
+    result.spans.push(span);
+    return true;
+  };
+  if ('date' in input) {
+    admit(Temporal.PlainDate.from(input.date));
+    return result;
+  }
+  const original = dateTime(input.dtstart, input.timezone);
+  const originalWall = plain(original);
+  // A cross-date rollback can leave the end on the preceding wall date.
+  // Include the following date completely; envelope clipping discards extra candidates.
+  const upper = Temporal.Instant.fromEpochMilliseconds(envelope.end)
+    .toZonedDateTimeISO(input.timezone)
+    .add({ days: 2 })
+    .startOfDay();
+  const until =
+    input.until === undefined
+      ? upper.toPlainDateTime()
+      : dateTime(input.until, input.timezone, true);
+  const untilDate =
+    input.until !== undefined && /^\d{4}-\d{2}-\d{2}$/.test(input.until)
+      ? Temporal.PlainDate.from(input.until)
+      : undefined;
+  if (
+    !untilDate &&
+    (until instanceof Temporal.ZonedDateTime
+      ? Temporal.ZonedDateTime.compare(
+          until,
+          anchorFor(original.toPlainDate(), original, input.timezone),
+        ) < 0
+      : Temporal.PlainDateTime.compare(until, originalWall) < 0)
+  )
+    return result;
+  const anchorWallTime = original.toPlainTime();
+  // Iterate wall dates in UTC so zone skips cannot normalize a candidate date.
+  // The callback applies the original date cutoff or the exact datetime UNTIL.
+  const untilDateEnd = (untilDate ?? until.toPlainDate())
+    // An instant after a midnight rollback can have the preceding local date.
+    // Keep the later wall date available for the callback's exact-instant filter.
+    .add({ days: until instanceof Temporal.ZonedDateTime ? 1 : 0 })
+    .toPlainDateTime('23:59:59.999')
+    .toZonedDateTime('UTC');
+  const upperDate = upper.toPlainDateTime().toZonedDateTime('UTC');
+  // Only midnight anchors with interval 1 and no COUNT may skip periods.
+  const anchor =
+    advanceAnchor &&
+    (input.interval === undefined || input.interval === 1) &&
+    input.count === undefined &&
+    anchorWallTime.equals('00:00')
+      ? advance(originalWall, envelope, input)
+      : originalWall;
+  const positional = !!input.bysetpos?.length;
+  const unit = periodUnit(input);
+  const firstPeriod = periodStart(anchor.toPlainDate(), input);
+  const bound =
+    Temporal.ZonedDateTime.compare(untilDateEnd, upperDate) < 0 ? untilDateEnd : upperDate;
+  const lastPeriod = periodStart(bound.toPlainDate(), input);
+  if (Temporal.PlainDate.compare(firstPeriod, lastPeriod) > 0) return result;
+  // 1.5.2 tests UNTIL only while visiting candidates in its monthly loop.
+  // Every supported loop advances at least one authored period per iteration.
+  // Exhaustion after the final query period is complete, even with no candidates.
+  const maxIterations =
+    Math.floor(firstPeriod.until(lastPeriod, { largestUnit: unit })[unit] / (input.interval ?? 1)) +
+    1;
+  const engine = new RRuleTemporal({
+    freq: input.frequency,
+    dtstart: firstPeriod.toPlainDateTime(anchorWallTime).toZonedDateTime('UTC'),
+    // Positions must see the entire final period before UNTIL and envelope admission.
+    until: positional
+      ? lastPeriod
+          .add({ [unit]: 1 })
+          .toZonedDateTime('UTC')
+          .subtract({ milliseconds: 1 })
+      : bound,
+    interval: input.interval,
+    wkst: allowedWeekdays[input.wkst ?? 0],
+    byDay:
+      input.frequency !== 'DAILY' && input.byweekday?.length
+        ? input.byweekday.map((day) => allowedWeekdays[day])
+        : input.frequency === 'WEEKLY' && !input.bymonthday?.length
+          ? [allowedWeekdays[(original.dayOfWeek - 1) as Weekday]]
+          : undefined,
+    byMonth: input.bymonth,
+    // Explicitly preserve the implicit monthly day; 1.5.2's fallback otherwise
+    // constrains a 31st through February and drifts subsequent months.
+    byMonthDay: input.bymonthday?.length
+      ? input.bymonthday
+      : input.frequency === 'MONTHLY' && !input.byweekday?.length
+        ? [original.day]
+        : undefined,
+    tzid: 'UTC',
+    includeDtstart: false,
+    maxIterations,
+  });
+  // Version 1.5.2 can replay the iterator when applying its final count filter.
+  // Admit each local date once so replay cannot consume COUNT or the cap twice.
+  const visited = new Set<string>();
+  let admitted = 0;
+  const visit = (date: Spec.Temporal.PlainDate): boolean => {
+    if (result.capped || admitted === input.count) return false;
+    if (Temporal.PlainDate.compare(date, original.toPlainDate()) < 0) return true;
+    const key = date.toString();
+    if (visited.has(key)) return true;
+    visited.add(key);
+    if (untilDate) {
+      if (Temporal.PlainDate.compare(date, untilDate) > 0) return true;
+    } else if (
+      until instanceof Temporal.ZonedDateTime
+        ? Temporal.ZonedDateTime.compare(anchorFor(date, original, input.timezone), until) > 0
+        : Temporal.PlainDateTime.compare(date.toPlainDateTime(anchorWallTime), until) > 0
+    )
+      return true;
+    if (!date.toZonedDateTime(input.timezone).toPlainDate().equals(date)) return true;
+    // Lifetime COUNT includes existing dates before the envelope, but never skipped dates.
+    admitted++;
+    return admit(date);
+  };
+  let candidateCount = 0;
+  let period = '';
+  let candidates: Spec.Temporal.PlainDate[] = [];
+  const flush = (): boolean => {
+    const selected = candidates.filter((_, index) =>
+      input.bysetpos?.some((position) =>
+        position > 0 ? index === position - 1 : index === candidates.length + position,
+      ),
+    );
+    candidates = [];
+    return selected.every(visit);
+  };
+  try {
+    engine.all((occurrence, index) => {
+      const date = occurrence.toPlainDate();
+      // Replayed callback indices restart at zero. They must not enlarge a
+      // buffered period, especially when the whole query has only one candidate.
+      if (positional && index < candidateCount) return false;
+      candidateCount++;
+      // DAILY BYDAY re-anchors the engine; filter the authored sequence here.
+      if (
+        input.frequency === 'DAILY' &&
+        input.byweekday?.length &&
+        !input.byweekday.includes((date.dayOfWeek - 1) as Weekday)
+      )
+        return true;
+      if (!positional) return visit(date);
+      const key = periodStart(date, input).toString();
+      if (key !== period) {
+        if (!flush()) return false;
+        period = key;
+      }
+      candidates.push(date);
+      return true;
+    });
+  } catch (error) {
+    if (
+      !(error instanceof Error) ||
+      error.message !== `Maximum iterations (${maxIterations}) exceeded in all()`
+    )
+      throw error;
+  }
+  flush();
+  return result;
+}
+
+// Validate temporal fields even when the display window has no elapsed time.
+export function validateDates(input: RosterRule | RosterDate): void {
+  if ('date' in input) {
+    Temporal.PlainDate.from(input.date).toZonedDateTime(input.timezone);
+    return;
+  }
+  plain(dateTime(input.dtstart, input.timezone)).toZonedDateTime(input.timezone);
+  if (input.until !== undefined)
+    plain(dateTime(input.until, input.timezone, true)).toZonedDateTime(input.timezone);
+}
+
+function hoursFor(date: Spec.Temporal.PlainDate, input: RosterRule | RosterDate): Window {
+  const midnight = date.toPlainDateTime();
+  const dayStart = date.toZonedDateTime(input.timezone);
+  if (!dayStart.toPlainDate().equals(date)) {
+    return { start: dayStart.epochMilliseconds, end: dayStart.epochMilliseconds };
+  }
+  const wholeDay = input.hourstart === undefined && input.hourend === undefined;
+  // Whole-day bounds resolve PlainDates to first instants. Explicit hours use
+  // compatible wall time, choosing the earlier repeat and advancing skips.
+  const at = (hour: number) => {
+    const wall = midnight.add({ milliseconds: Math.round(hour * 3_600_000) });
+    return (wholeDay ? wall.toPlainDate() : wall).toZonedDateTime(input.timezone).epochMilliseconds;
+  };
+  return { start: at(input.hourstart ?? 0), end: at(input.hourend ?? 24) };
+}
+
+function dateTime(value: string, timezone: string, endOfDate = false): RuleDateTime {
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    const date = Temporal.PlainDate.from(value);
+    return date.toPlainDateTime(endOfDate ? '23:59:59.999' : '00:00');
+  }
+  if (/(?:Z|[+-]\d{2}:?\d{2})(?:\[[^\]]*\])?$/i.test(value)) {
+    return Temporal.Instant.from(value).toZonedDateTimeISO(timezone);
+  }
+  return Temporal.PlainDateTime.from(value);
+}
+
+function plain(value: RuleDateTime): Spec.Temporal.PlainDateTime {
+  return value instanceof Temporal.ZonedDateTime ? value.toPlainDateTime() : value;
+}
+
+// Keep the original wall time and back up one period so WKST/BYDAY cannot lose
+// an earlier candidate. A monthly jump must never constrain the 31st to the 28th.
+function advance(
+  original: Spec.Temporal.PlainDateTime,
+  envelope: Window,
+  input: RosterRule,
+): Spec.Temporal.PlainDateTime {
+  // Include the local date crossing the left edge, regardless of anchor wall time.
+  const lower = Temporal.Instant.fromEpochMilliseconds(envelope.start)
+    .toZonedDateTimeISO(input.timezone)
+    .startOfDay();
+  const unit =
+    input.frequency === 'MONTHLY' ? 'months' : input.frequency === 'WEEKLY' ? 'weeks' : 'days';
+  const originalDate = original.toPlainDate();
+  const interval = input.interval ?? 1;
+  const distance = originalDate.until(lower.toPlainDate(), { largestUnit: unit })[unit];
+  let steps = Math.max(0, Math.floor(distance / interval) - 1);
+  while (steps > 0) {
+    const candidate = originalDate.add({ [unit]: steps * interval });
+    if (
+      (unit !== 'weeks' || candidate.dayOfWeek === originalDate.dayOfWeek) &&
+      (unit !== 'months' || candidate.day === originalDate.day) &&
+      candidate.toZonedDateTime(input.timezone).toPlainDate().equals(candidate)
+    )
+      return candidate.toPlainDateTime(original.toPlainTime());
+    steps--;
+  }
+  return original;
+}
+
+// Prefer the original offset in repeated time; otherwise resolve skips compatibly.
+function anchorFor(
+  date: Spec.Temporal.PlainDate,
+  original: RuleDateTime,
+  timezone: string,
+): Spec.Temporal.ZonedDateTime {
+  return original instanceof Temporal.ZonedDateTime
+    ? original.with({ year: date.year, month: date.month, day: date.day }, { offset: 'prefer' })
+    : date.toPlainDateTime(original.toPlainTime()).toZonedDateTime(timezone);
+}
+
+function periodUnit(input: RosterRule): 'days' | 'weeks' | 'months' {
+  return input.frequency === 'MONTHLY' ? 'months' : input.frequency === 'WEEKLY' ? 'weeks' : 'days';
+}
+
+function periodStart(date: Spec.Temporal.PlainDate, input: RosterRule): Spec.Temporal.PlainDate {
+  if (input.frequency === 'MONTHLY') return date.with({ day: 1 });
+  if (input.frequency === 'WEEKLY')
+    return date.subtract({ days: (date.dayOfWeek - 1 - (input.wkst ?? 0) + 7) % 7 });
+  return date;
+}

package/src/adapters/rrule/types.ts

@@ -0,0 +1,52 @@
+import type { Gap, Interval, Weekday, Window } from '../../core';
+
+export type RosterRule = {
+  id: string;
+  kind: 'include' | 'exclude';
+  frequency: 'DAILY' | 'WEEKLY' | 'MONTHLY';
+  dtstart: string;
+  until?: string;
+  count?: number;
+  interval?: number;
+  wkst?: Weekday;
+  byweekday?: Weekday[];
+  bymonth?: number[];
+  bymonthday?: number[];
+  bysetpos?: number[];
+  /** Local hours in timezone, end-exclusive; 24 means next local midnight. */
+  hourstart: number;
+  hourend: number;
+  timezone: string;
+};
+
+export type RosterDate = {
+  id: string;
+  kind: 'include' | 'exclude';
+  date: string;
+  timezone: string;
+  note?: string;
+  /** Both hours present for a partial day, or both absent for the whole day. */
+  hourstart?: number;
+  hourend?: number;
+};
+
+export type RuleSet = { rules: RosterRule[]; dates: RosterDate[] };
+export type ExpandOptions = {
+  cache?: { maxEntries?: number; maxEnvelopes?: number };
+  caps?: { perRuleOccurrences?: number; totalOccurrences?: number };
+};
+export type ExpandStats = {
+  rules: number;
+  dates: number;
+  expanded: number;
+  cacheHits: number;
+  cacheMisses: number;
+};
+export type ExpandResult = {
+  intervals: Interval[];
+  gaps: Gap[];
+  envelope: Window;
+  complete: boolean;
+  truncated: Array<{ id: string; droppedAtLeast: number }>;
+  stats: ExpandStats;
+};

package/src/adapters/rrule/validate.ts

@@ -0,0 +1,78 @@
+import type { Window } from '../../core';
+import type { RosterDate, RosterRule } from './types';
+
+export function validateWindow(window: Window): void {
+  if (
+    !Number.isSafeInteger(window.start) ||
+    !Number.isSafeInteger(window.end) ||
+    window.start > window.end
+  ) {
+    throw new RangeError('window must have integer epoch milliseconds with start <= end');
+  }
+}
+
+export function nonnegativeInteger(value: number, name: string): number {
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new RangeError(`${name} must be a nonnegative integer`);
+  return value;
+}
+
+export function validateInput(input: RosterRule | RosterDate): void {
+  if (!input.id || !['include', 'exclude'].includes(input.kind)) {
+    throw new RangeError('Each rule or date needs an id and an include or exclude kind');
+  }
+  // Bound date strings before any regex sees them; a full offset-and-zone
+  // form is under 50 characters, and unbounded input would scan quadratically.
+  for (const name of ['dtstart', 'until', 'date'] as const) {
+    const value =
+      name in input ? (input as Partial<Record<typeof name, unknown>>)[name] : undefined;
+    if (value !== undefined && (typeof value !== 'string' || value.length > 64))
+      throw new RangeError(`${input.id}: ${name} must be a string of at most 64 characters`);
+  }
+  const { hourstart, hourend } = input;
+  if ((hourstart === undefined) !== (hourend === undefined)) {
+    throw new RangeError(`${input.id}: hourstart and hourend must both be present or both absent`);
+  }
+  if ('frequency' in input) {
+    if (!['DAILY', 'WEEKLY', 'MONTHLY'].includes(input.frequency))
+      throw new RangeError('Unsupported frequency');
+    if (hourstart === undefined) throw new RangeError('Rules require hourstart and hourend');
+    for (const name of ['count', 'interval'] as const) {
+      const value = input[name];
+      if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0))
+        throw new RangeError(`${name} must be a positive integer`);
+    }
+    validateNumbers(input.wkst === undefined ? undefined : [input.wkst], 'wkst', 0, 6);
+    validateNumbers(input.byweekday, 'byweekday', 0, 6);
+    validateNumbers(input.bymonth, 'bymonth', 1, 12);
+    validateNumbers(input.bymonthday, 'bymonthday', -31, 31, true);
+    validateNumbers(input.bysetpos, 'bysetpos', -366, 366, true);
+  }
+  if (
+    hourstart !== undefined &&
+    hourend !== undefined &&
+    (!Number.isFinite(hourstart) ||
+      !Number.isFinite(hourend) ||
+      hourstart < 0 ||
+      hourstart >= hourend ||
+      hourend > 24)
+  ) {
+    throw new RangeError(`${input.id}: hours must satisfy 0 <= hourstart < hourend <= 24`);
+  }
+}
+
+function validateNumbers(
+  values: number[] | undefined,
+  name: string,
+  min: number,
+  max: number,
+  nonzero = false,
+): void {
+  if (
+    values?.some(
+      (value) => !Number.isInteger(value) || value < min || value > max || (nonzero && value === 0),
+    )
+  ) {
+    throw new RangeError(`Invalid ${name}`);
+  }
+}

package/src/components/layers/README.md

@@ -0,0 +1,15 @@
+# layers
+
+This area is about a layer; its children are intervals and gaps. Both
+projections draw the same components, so they live above Roster and Schedule.
+
+- Root entry exports: `RosterInterval`, `RosterGap`, `IntervalInput`, `GapInput`
+- `layers.types.ts`: the component input contract both projections pass
+- `parts/interval.tsx`, `parts/gap.tsx`: the default components
+- `utils/styles.ts`: content-keyed style objects per layer
+
+Imports core only. Tests: `test/components/layers`.
+
+Both projections accept intervalComponent and gapComponent as ComponentType inputs.
+Their data-owning lane or column mounts the component with the final rect, layer,
+and lane; interval inputs also carry highlighted. No renderer calls a slot function.

package/src/components/layers/layers.types.ts

@@ -0,0 +1,6 @@
+import type { Lane, Layer, Rect } from '../../core';
+
+/** One covered span of a layer, positioned by the projection; `highlighted` follows the active source. */
+export type IntervalInput = { rect: Rect; layer: Layer; lane: Lane; highlighted: boolean };
+/** One removed span of a layer, positioned by the projection. */
+export type GapInput = { rect: Rect; layer: Layer; lane: Lane };

package/src/components/layers/parts/gap.tsx

@@ -0,0 +1,5 @@
+import type { GapInput } from '../layers.types';
+
+export function RosterGap(_input: GapInput) {
+  return null;
+}

package/src/components/layers/parts/interval.tsx

@@ -0,0 +1,24 @@
+import { View } from 'react-native';
+import type { IntervalInput } from '../layers.types';
+import { stylesFor } from '../utils/styles';
+
+export function RosterInterval({ rect, layer, highlighted }: IntervalInput) {
+  const styles = stylesFor(layer);
+  const fill = highlighted ? styles.highlighted : styles.normal;
+  return (
+    <View
+      pointerEvents="none"
+      style={[
+        fill,
+        {
+          position: 'absolute',
+          left: rect.x,
+          top: rect.y,
+          width: rect.width,
+          height: rect.height,
+          zIndex: rect.z,
+        },
+      ]}
+    />
+  );
+}

package/src/components/layers/utils/styles.ts

@@ -0,0 +1,24 @@
+import type { ViewStyle } from 'react-native';
+import type { Layer } from '../../../core';
+import { structuralKey } from '../../../core/hash';
+
+const styles = new Map<string, { normal: ViewStyle; highlighted: ViewStyle }>();
+
+export function stylesFor(layer: Layer): { normal: ViewStyle; highlighted: ViewStyle } {
+  const key = structuralKey([layer.id, layer.style]);
+  let result = styles.get(key);
+  if (!result) {
+    const normal: ViewStyle = {
+      backgroundColor: layer.style.color,
+      opacity: layer.style.opacity ?? 1,
+      width: '100%',
+      height: '100%',
+    };
+    result = {
+      normal,
+      highlighted: { ...normal, backgroundColor: layer.style.highlightColor ?? layer.style.color },
+    };
+    styles.set(key, result);
+  }
+  return result;
+}

package/src/components/primitives/README.md

@@ -0,0 +1,12 @@
+# primitives
+
+Hookless building blocks shared by Roster and Schedule. Nothing here is a
+public export.
+
+- `press-point.tsx`, `press-point.web.tsx`, `press-point.types.ts`: pointer
+  coordinates relative to the pressed surface; the web file is selected by the
+  `browser` remap in package.json
+- `region-style.ts`: `regionStyle(structure, paint, override)`, which drops the
+  default paint when the override carries a NativeWind class entry
+
+Tests: `test/components/primitives`.

package/src/components/primitives/press-point.tsx

@@ -0,0 +1,5 @@
+import type { PressPoint, PressPointInput } from './press-point.types';
+
+export function pressPoint({ nativeEvent }: PressPointInput): PressPoint {
+  return { x: nativeEvent.locationX as number, y: nativeEvent.locationY as number };
+}

package/src/components/primitives/press-point.types.ts

@@ -0,0 +1,5 @@
+export type PressPointInput = {
+  nativeEvent: { locationX?: number; locationY?: number; clientX?: number; clientY?: number };
+  currentTarget?: unknown;
+};
+export type PressPoint = { x: number; y: number };

package/src/components/primitives/press-point.web.tsx

@@ -0,0 +1,19 @@
+import type { PressPoint, PressPointInput } from './press-point.types';
+
+export function pressPoint({ nativeEvent, currentTarget }: PressPointInput): PressPoint {
+  // React Native Web passes a DOM click, not a native responder event, to onPress.
+  const target = currentTarget as {
+    getBoundingClientRect(): { left: number; top: number; width: number; height: number };
+  };
+  const bounds = target.getBoundingClientRect();
+  return {
+    x:
+      typeof nativeEvent.clientX === 'number'
+        ? nativeEvent.clientX - bounds.left
+        : bounds.width / 2,
+    y:
+      typeof nativeEvent.clientY === 'number'
+        ? nativeEvent.clientY - bounds.top
+        : bounds.height / 2,
+  };
+}

package/src/components/primitives/region-style.ts

@@ -0,0 +1,21 @@
+import type { StyleProp, ViewStyle } from 'react-native';
+
+/**
+ * Compose a chrome region's style. React Native Web renders object styles
+ * inline, and inline paint beats any class, so a class entry in the override
+ * (NativeWind's `$$css` marker) replaces the region's default paint entirely.
+ * Structure always applies; native style overrides simply merge last.
+ */
+export function regionStyle(
+  structure: ViewStyle,
+  paint: ViewStyle,
+  override: StyleProp<ViewStyle>,
+): StyleProp<ViewStyle> {
+  return [structure, hasClassEntry(override) ? null : paint, override];
+}
+
+function hasClassEntry(style: unknown): boolean {
+  if (!style || typeof style !== 'object') return false;
+  if (Array.isArray(style)) return style.some((entry) => hasClassEntry(entry));
+  return '$$css' in style;
+}

package/src/components/roster/README.md

@@ -0,0 +1,29 @@
+# Roster
+
+This feature is about a roster; its children are lanes.
+
+- Root entry exports: `Roster`, `useRoster`, `RosterBodyLayout`, `RosterLaneList`, the other `RosterXxx` parts, and every
+  `XxxInput` slot input type from `roster.types.ts`
+
+- `index.tsx`: the chassis; calls `useRoster`, branches on `status`, composes zones
+- `use-roster.ts`: the hook; owns window, projection, scroll, geometry, and press
+- `layout.tsx`: arranges corner, header, label column, and body regions only
+- `roster.types.ts`: props, model, and every slot input type
+- `body-layout.tsx`: arranges grid and list nodes with horizontal scroll wiring
+- `parts/lane-list.tsx`: `RosterLaneList` owns LegendList and its lane render callback
+- `parts/`: collection-level parts (body, header, header cell, grid, corner, label column, empty)
+- `lanes/`: `LaneRow`, the interval-hover platform pair, and lane-local parts
+- `utils/`: ticks and the body content key
+
+Interval and gap components live in `../layers`; press geometry and `regionStyle`
+in `../primitives`. Zone contracts are documented in the README's Roster zones
+section and in `llms.txt`. Tests: `test/components/roster`.
+
+This feature is about a roster body; its children are lanes. `RosterBody` gates
+measurement and composes the body layout and lane list. The `onRowRender` prop on
+`RosterBody` and `RosterLaneList` is a development-only Profiler hook used by the
+gallery, not a supported customization point. Production Profiler callbacks are disabled.
+
+Input-bearing slots accept component types and mount in the data-owning parts.
+The chassis binds defaults once; emptyZone and cornerZone accept nodes. The body
+content key tracks interval and gap component identity, including class components.

package/src/components/roster/body-layout.tsx

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+import { ScrollView, View } from 'react-native';
+import type { BodyInput } from './roster.types';
+
+export function RosterBodyLayout({
+  scroll,
+  contentWidth,
+  viewport,
+  gridZone,
+  listZone,
+}: Pick<BodyInput, 'scroll' | 'contentWidth' | 'viewport'> & {
+  /** Noninteractive grid behind the lane list. */
+  gridZone: ReactNode;
+  /** Virtualized lane collection within the measured viewport. */
+  listZone: ReactNode;
+}) {
+  return (
+    <ScrollView
+      testID="roster-horizontal-scroll"
+      ref={scroll.bodyRef}
+      horizontal
+      onScroll={scroll.onBodyScroll}
+      scrollEventThrottle={16}
+      style={{ flex: 1 }}
+    >
+      <View style={{ width: contentWidth, height: viewport.height }}>
+        {gridZone}
+        {listZone}
+      </View>
+    </ScrollView>
+  );
+}