@nowline/layout 0.2.5 → 0.4.0

package/src/inline-date-pin-geometry.ts

@@ -0,0 +1,196 @@
+// Inline-date pin glyph placement.
+//
+// `after:DATE` paints a calendar glyph in the entity's top-LEFT decoration
+// slot; `before:DATE` paints it in the top-RIGHT slot. The two helpers
+// below produce `Point` coordinates for the glyph's top-left corner, plus
+// a `spilled` flag indicating whether the bar was too narrow to host the
+// glyph inside (item case only — containers always have room).
+//
+// Slot interleaving rules (per specs/rendering.md "Inline-date glyph"):
+//
+//   Item top-LEFT: glyph sits at the bar's leftmost slot when no link icon
+//   is present, otherwise one decoration step right of the link icon's
+//   right edge.
+//
+//   Item top-RIGHT: glyph sits at the bar's rightmost slot when no status
+//   dot or footnotes are present, one step LEFT of the status dot when no
+//   footnotes, and one step LEFT of the LEFTMOST footnote indicator when
+//   footnotes are present (so the inline-date glyph inserts at the LEFT
+//   end of the existing badge cluster rather than reordering it).
+//
+//   Container (group, parallel): glyph sits at the bounding box's top
+//   corners with the standard inset. Containers don't carry status dots
+//   or footnote indicators in their own decoration row, so no
+//   interleaving math is needed.
+
+import {
+    INLINE_DATE_GLYPH_GAP_PX,
+    INLINE_DATE_GLYPH_INSET_LEFT_PX,
+    INLINE_DATE_GLYPH_INSET_RIGHT_PX,
+    INLINE_DATE_GLYPH_INSET_TOP_PX,
+    INLINE_DATE_GLYPH_TILE_SIZE_PX,
+    ITEM_CAPTION_SPILL_GAP_PX,
+    ITEM_FOOTNOTE_INDICATOR_INSET_RIGHT_PX,
+    ITEM_FOOTNOTE_INDICATOR_STEP_PX,
+    ITEM_LINK_ICON_INSET_PX,
+    ITEM_LINK_ICON_TILE_SIZE_PX,
+    ITEM_STATUS_DOT_INSET_RIGHT_PX,
+    ITEM_STATUS_DOT_RADIUS_PX,
+    MIN_BAR_WIDTH_FOR_INLINE_DATE_PX,
+} from './item-bar-geometry.js';
+import type { BoundingBox, InlineDatePin, Point } from './types.js';
+
+export interface ItemInlineDatePinInputs {
+    box: BoundingBox;
+    /** ISO date string from `after:DATE`, or undefined when no inline `after`. */
+    afterDate: string | undefined;
+    /** ISO date string from `before:DATE`, or undefined when no inline `before`. */
+    beforeDate: string | undefined;
+    hasLinkIcon: boolean;
+    /** Number of footnote indicators rendered in the bar's top-RIGHT cluster. */
+    footnoteCount: number;
+}
+
+/**
+ * Compute inline-date pin glyph placements for an item bar. Returns an
+ * empty array when neither `afterDate` nor `beforeDate` is set.
+ *
+ * Item bars participate in the narrow-bar spill family — when the bar is
+ * narrower than `MIN_BAR_WIDTH_FOR_INLINE_DATE_PX`, the `before:` glyph
+ * spills RIGHT of the bar (joining the status-dot / footnote spill
+ * column) and the `after:` glyph spills LEFT of the bar's leading edge
+ * so the side semantics stay readable.
+ */
+export function computeItemInlineDatePins(opts: ItemInlineDatePinInputs): InlineDatePin[] {
+    const { box, afterDate, beforeDate, hasLinkIcon, footnoteCount } = opts;
+    if (!afterDate && !beforeDate) return [];
+
+    const pins: InlineDatePin[] = [];
+    const tileSize = INLINE_DATE_GLYPH_TILE_SIZE_PX;
+    const topY = box.y + INLINE_DATE_GLYPH_INSET_TOP_PX;
+    const spilled = box.width < MIN_BAR_WIDTH_FOR_INLINE_DATE_PX;
+
+    if (afterDate) {
+        const insideLeftX = hasLinkIcon
+            ? box.x +
+              ITEM_LINK_ICON_INSET_PX +
+              ITEM_LINK_ICON_TILE_SIZE_PX +
+              INLINE_DATE_GLYPH_GAP_PX
+            : box.x + INLINE_DATE_GLYPH_INSET_LEFT_PX;
+        const glyphLeft: Point = spilled
+            ? {
+                  x: box.x - ITEM_CAPTION_SPILL_GAP_PX - tileSize,
+                  y: topY,
+              }
+            : { x: insideLeftX, y: topY };
+        pins.push({
+            side: 'after',
+            isoDate: afterDate,
+            glyphTopLeft: glyphLeft,
+            glyphSize: tileSize,
+            spilled,
+        });
+    }
+
+    if (beforeDate) {
+        // Walk LEFT from the rightmost top-decoration slot:
+        //   - rightmost footnote anchors at (box.right - INSET_RIGHT_PX)
+        //   - leftmost footnote sits one step further left per extra digit
+        //   - status dot left edge sits at (box.right - INSET_RIGHT - DOT_RADIUS)
+        //   - inline-date glyph sits one INLINE_DATE_GLYPH_GAP_PX further left
+        const rightEdge = box.x + box.width;
+        let anchorRightX: number;
+        if (footnoteCount > 0) {
+            const leftmostFootnoteCenter =
+                rightEdge -
+                ITEM_FOOTNOTE_INDICATOR_INSET_RIGHT_PX -
+                (footnoteCount - 1) * ITEM_FOOTNOTE_INDICATOR_STEP_PX;
+            anchorRightX = leftmostFootnoteCenter - INLINE_DATE_GLYPH_GAP_PX;
+        } else {
+            const dotLeftEdge =
+                rightEdge - ITEM_STATUS_DOT_INSET_RIGHT_PX - ITEM_STATUS_DOT_RADIUS_PX;
+            anchorRightX = dotLeftEdge - INLINE_DATE_GLYPH_GAP_PX;
+        }
+        const insideRightX = anchorRightX - tileSize;
+        const glyphLeft: Point = spilled
+            ? {
+                  x: rightEdge + ITEM_CAPTION_SPILL_GAP_PX,
+                  y: topY,
+              }
+            : { x: insideRightX, y: topY };
+        pins.push({
+            side: 'before',
+            isoDate: beforeDate,
+            glyphTopLeft: glyphLeft,
+            glyphSize: tileSize,
+            spilled,
+        });
+    }
+
+    return pins;
+}
+
+export interface ContainerInlineDatePinInputs {
+    /** Bounding box that anchors the glyph corners. For styled groups and
+     *  bracketed parallels this is the visible box; for unstyled groups
+     *  and bare parallels it is the logical bounding box (leftmost child
+     *  start, rightmost child end, top of the highest child row). */
+    box: BoundingBox;
+    afterDate: string | undefined;
+    beforeDate: string | undefined;
+}
+
+/**
+ * Compute inline-date pin glyph placements for a container (group or
+ * parallel). The glyphs sit flush to the box's top-LEFT (`after`) and
+ * top-RIGHT (`before`) corners with the standard inset; containers
+ * never spill (they always have room for a 12 px tile in their own
+ * top-decoration row).
+ */
+export function computeContainerInlineDatePins(
+    opts: ContainerInlineDatePinInputs,
+): InlineDatePin[] {
+    const { box, afterDate, beforeDate } = opts;
+    if (!afterDate && !beforeDate) return [];
+
+    const pins: InlineDatePin[] = [];
+    const tileSize = INLINE_DATE_GLYPH_TILE_SIZE_PX;
+    const topY = box.y + INLINE_DATE_GLYPH_INSET_TOP_PX;
+
+    if (afterDate) {
+        pins.push({
+            side: 'after',
+            isoDate: afterDate,
+            glyphTopLeft: { x: box.x + INLINE_DATE_GLYPH_INSET_LEFT_PX, y: topY },
+            glyphSize: tileSize,
+            spilled: false,
+        });
+    }
+
+    if (beforeDate) {
+        pins.push({
+            side: 'before',
+            isoDate: beforeDate,
+            glyphTopLeft: {
+                x: box.x + box.width - INLINE_DATE_GLYPH_INSET_RIGHT_PX - tileSize,
+                y: topY,
+            },
+            glyphSize: tileSize,
+            spilled: false,
+        });
+    }
+
+    return pins;
+}
+
+/**
+ * Returns the first ISO date literal in `values`, or undefined when none
+ * is present. The validator enforces "at most one inline date per
+ * direction" so this lookup is unambiguous.
+ */
+export function pickInlineDate(values: readonly string[]): string | undefined {
+    for (const v of values) {
+        if (/^\d{4}-\d{2}-\d{2}$/.test(v)) return v;
+    }
+    return undefined;
+}

package/src/item-bar-geometry.ts

@@ -116,6 +116,55 @@ export const MIN_BAR_WIDTH_FOR_LINK_AND_DOT_PX =
  */
 export const MIN_BAR_WIDTH_FOR_FOOTNOTE_PX = ITEM_FOOTNOTE_INDICATOR_INSET_RIGHT_PX + 1;
 
+// ---- Inline-date glyph (after:DATE / before:DATE corner badge) ---
+//
+// Renders the renderer's built-in `calendar` SVG at top-LEFT (`after`)
+// or top-RIGHT (`before`) of the entity bar. Sized as a sibling of
+// the status dot and footnote indicators (smaller than the link tile)
+// so the top-decoration row stays visually unified. See
+// specs/rendering.md "Inline-date glyph".
+
+/** Side length (px) of the inline-date calendar glyph tile. */
+export const INLINE_DATE_GLYPH_TILE_SIZE_PX = 12;
+
+/** Distance (px) from the bar's left edge to the glyph's left edge
+ *  when the glyph sits at the leftmost top-decoration slot (no link
+ *  icon present). */
+export const INLINE_DATE_GLYPH_INSET_LEFT_PX = 6;
+
+/** Distance (px) from the bar's right edge to the glyph's right edge
+ *  when the glyph sits at the rightmost top-decoration slot (no
+ *  status dot or footnote present). */
+export const INLINE_DATE_GLYPH_INSET_RIGHT_PX = 6;
+
+/** Distance (px) from the bar's top edge to the glyph's top edge. */
+export const INLINE_DATE_GLYPH_INSET_TOP_PX = 5;
+
+/** Horizontal gap (px) between the inline-date glyph and an adjacent
+ *  decoration (link icon on the left, status dot / footnote indicator
+ *  on the right). Matches the existing decoration spill gap so the
+ *  top-decoration row reads as one rhythm. */
+export const INLINE_DATE_GLYPH_GAP_PX = ITEM_DECORATION_SPILL_GAP_PX;
+
+/**
+ * Minimum bar width (px) needed to host the inline-date glyph inside
+ * the bar. Below this, the glyph spills:
+ *   - `before:` glyph spills RIGHT into the column the status dot
+ *     uses (same family of decorations, same step pitch).
+ *   - `after:` glyph spills LEFT of the bar's leading edge so the
+ *     side semantics (after vs before) stay readable in the spill.
+ *
+ * The threshold reserves room for the glyph itself plus a small
+ * clearance from the link-icon column (when present) so the two
+ * glyphs don't overlap inside narrow bars.
+ */
+export const MIN_BAR_WIDTH_FOR_INLINE_DATE_PX =
+    INLINE_DATE_GLYPH_INSET_LEFT_PX +
+    INLINE_DATE_GLYPH_TILE_SIZE_PX +
+    INLINE_DATE_GLYPH_GAP_PX +
+    INLINE_DATE_GLYPH_TILE_SIZE_PX +
+    INLINE_DATE_GLYPH_INSET_RIGHT_PX;
+
 // ---- Label chips (along the bar's bottom) ------------------------
 
 /** Height (px) of a label chip rectangle. */

package/src/layout.ts

@@ -40,6 +40,7 @@ import {
     HEADER_TITLE_TO_AUTHOR_GAP_PX,
 } from './header-card-geometry.js';
 import { localeStrings } from './i18n.js';
+import { computeItemInlineDatePins, pickInlineDate } from './inline-date-pin-geometry.js';
 import {
     ITEM_CAPTION_INSET_X_PX,
     ITEM_CAPTION_META_BASELINE_OFFSET_PX,
@@ -226,11 +227,15 @@ function sequenceItem(
     // "one engineer-week of work left".
     const totalEffortDays = deriveTotalEffortDays(props, ctx.sizes, ctx.cal);
     const afterRaw = propValues(props, 'after');
-    const beforeRaw = propValue(props, 'before');
+    const beforeRaw = propValues(props, 'before');
     const dateRaw = propValue(props, 'date');
     const remainingDays = resolveDuration(propValue(props, 'remaining'), ctx.sizes, ctx.cal);
 
-    // Resolve start x: explicit date > after-chain > cursor position
+    // Resolve start x: explicit date > after-chain > cursor position.
+    // `after:` accepts both entity ids (looked up in entityRightEdges) and
+    // inline ISO date literals (resolved through the time scale). The
+    // validator enforces "at most one inline date per direction" so at most
+    // one element will hit the date path per item.
     let startX = cursor.x;
     const explicitDate = parseDate(dateRaw);
     if (explicitDate) {
@@ -239,6 +244,12 @@ function sequenceItem(
     } else if (afterRaw.length > 0) {
         let maxEnd = cursor.x;
         for (const ref of afterRaw) {
+            const inlineDate = parseDate(ref);
+            if (inlineDate) {
+                const xd = ctx.scale.forwardWithinDomain(inlineDate);
+                if (xd !== null) maxEnd = Math.max(maxEnd, xd);
+                continue;
+            }
             const endX = ctx.entityRightEdges.get(ref);
             if (endX !== undefined) maxEnd = Math.max(maxEnd, endX);
         }
@@ -286,24 +297,38 @@ function sequenceItem(
     const chipInsideAvailWidth = Math.max(0, visualWidthPredict - 2 * ITEM_CAPTION_INSET_X_PX);
     const chipsOutside = chipSamples.length > 0 && chipRowWidth > chipInsideAvailWidth;
 
-    // Handle `before:` — item must end by the named anchor/milestone x.
+    // Handle `before:` — item must end by the earliest cap. Each cap is
+    // either an entity id (looked up in entityLeftEdges) or an inline ISO
+    // date literal (resolved through the time scale). The validator enforces
+    // "at most one inline date per direction" so at most one element per
+    // before-list will hit the date path.
     let hasOverflow = false;
     let overflowBox: BoundingBox | undefined;
     let overflowAnchorId: string | undefined;
-    if (beforeRaw) {
-        const beforeX = ctx.entityLeftEdges.get(beforeRaw);
-        if (beforeX !== undefined) {
-            if (logicalRight > beforeX) {
-                hasOverflow = true;
-                overflowBox = {
-                    x: beforeX,
-                    y: cursor.y,
-                    width: logicalRight - beforeX,
-                    height: ctx.bandScale.bandwidth(),
-                };
-                overflowAnchorId = beforeRaw;
+    if (beforeRaw.length > 0) {
+        let earliestCapX: number | undefined;
+        let earliestCapRef: string | undefined;
+        for (const ref of beforeRaw) {
+            const inlineDate = parseDate(ref);
+            const capX = inlineDate
+                ? (ctx.scale.forwardWithinDomain(inlineDate) ?? undefined)
+                : ctx.entityLeftEdges.get(ref);
+            if (capX === undefined) continue;
+            if (earliestCapX === undefined || capX < earliestCapX) {
+                earliestCapX = capX;
+                earliestCapRef = ref;
             }
         }
+        if (earliestCapX !== undefined && logicalRight > earliestCapX) {
+            hasOverflow = true;
+            overflowBox = {
+                x: earliestCapX,
+                y: cursor.y,
+                width: logicalRight - earliestCapX,
+                height: ctx.bandScale.bandwidth(),
+            };
+            overflowAnchorId = earliestCapRef;
+        }
     }
 
     // Progress fraction
@@ -695,6 +720,14 @@ function sequenceItem(
     // `step − bandwidth` px below the (now-taller) bar bottom.
     cursor.height = Math.max(cursor.height, ctx.bandScale.step() + chipBarExtra);
 
+    const inlineDatePins = computeItemInlineDatePins({
+        box: itemBox,
+        afterDate: pickInlineDate(afterRaw),
+        beforeDate: pickInlineDate(beforeRaw),
+        hasLinkIcon,
+        footnoteCount: footnoteIndicators.length,
+    });
+
     const result: PositionedItem = {
         kind: 'item',
         id,
@@ -725,6 +758,7 @@ function sequenceItem(
         capacity,
         size: sizeResolved,
         style,
+        inlineDatePins: inlineDatePins.length > 0 ? inlineDatePins : undefined,
     };
     return result;
 }
@@ -895,6 +929,11 @@ function predictItemChipExtraHeight(item: ItemDeclaration, ctx: LayoutContext):
 // pin) > `start:` (fixed pin) > `after:` (chain after refs) > sequential
 // default (continue from `seqDefault`, which is the lane's rightmost time
 // cursor across all rows).
+//
+// `after:` accepts both entity ids (looked up in `ctx.entityRightEdges`) and
+// inline ISO date literals (looked up via `ctx.scale.forwardWithinDomain`).
+// The validator already enforces "at most one inline date per direction" so
+// at most one element in the list will hit the date path.
 function resolveChildStart(
     props: EntityProperty[],
     seqDefault: number,
@@ -911,6 +950,12 @@ function resolveChildStart(
     if (afterRefs.length > 0) {
         let maxEnd = laneLeftX;
         for (const ref of afterRefs) {
+            const inlineDate = parseDate(ref);
+            if (inlineDate) {
+                const xd = ctx.scale.forwardWithinDomain(inlineDate);
+                if (xd !== null) maxEnd = Math.max(maxEnd, xd);
+                continue;
+            }
             const endX = ctx.entityRightEdges.get(ref);
             if (endX !== undefined) maxEnd = Math.max(maxEnd, endX);
         }
@@ -1121,7 +1166,14 @@ function computeContentEndDay(
     const milestoneEnd = new Map<string, number>();
     let maxDay = 0;
 
-    const refEndDay = (ref: string): number => {
+    // Resolve a single `after:` element to a day-offset from `startDate`.
+    // The element is either an entity id (looked up in itemEnd / anchorEnd /
+    // milestoneEnd) or an inline ISO date literal (converted directly via
+    // `daysBetween`). The validator already enforces "at most one inline date
+    // per direction", so at most one element per list will hit the date path.
+    const resolveAfterDay = (ref: string): number => {
+        const inlineDate = parseDate(ref);
+        if (inlineDate) return daysBetween(startDate, inlineDate);
         if (itemEnd.has(ref)) return itemEnd.get(ref)!;
         if (anchorEnd.has(ref)) return anchorEnd.get(ref)!;
         if (milestoneEnd.has(ref)) return milestoneEnd.get(ref)!;
@@ -1164,7 +1216,7 @@ function computeContentEndDay(
             } else if (startProp) {
                 start = daysBetween(startDate, startProp);
             } else if (afterRefs.length > 0) {
-                start = Math.max(prevEnd, ...afterRefs.map(refEndDay));
+                start = Math.max(prevEnd, ...afterRefs.map(resolveAfterDay));
             }
             const end = start + dur;
             if (node.name) itemEnd.set(node.name, end);
@@ -1172,17 +1224,30 @@ function computeContentEndDay(
         }
         if (isParallelBlock(node)) {
             // All children share the parallel's start; the block's effective
-            // end is the maximum child end.
-            let parallelEnd = prevEnd;
+            // end is the maximum child end. The parallel's own `after:`
+            // (including inline-date pins) widens that shared start.
+            const afterRefs = propValues(node.properties, 'after');
+            const containerStart =
+                afterRefs.length > 0
+                    ? Math.max(prevEnd, ...afterRefs.map(resolveAfterDay))
+                    : prevEnd;
+            let parallelEnd = containerStart;
             for (const child of node.content) {
                 if (child.$type === 'DescriptionDirective') continue;
-                const childEnd = walkNode(child as ItemDeclaration | GroupBlock, prevEnd);
+                const childEnd = walkNode(child as ItemDeclaration | GroupBlock, containerStart);
                 parallelEnd = Math.max(parallelEnd, childEnd);
             }
             return parallelEnd;
         }
         if (isGroupBlock(node)) {
-            return walkLane(node.content as SwimlaneDeclaration['content'], prevEnd);
+            // The group's own `after:` (including inline-date pins) widens
+            // the baseline before walking the inner sequential lane.
+            const afterRefs = propValues(node.properties, 'after');
+            const containerStart =
+                afterRefs.length > 0
+                    ? Math.max(prevEnd, ...afterRefs.map(resolveAfterDay))
+                    : prevEnd;
+            return walkLane(node.content as SwimlaneDeclaration['content'], containerStart);
         }
         return prevEnd;
     };
@@ -1202,7 +1267,12 @@ function computeContentEndDay(
         }
         const after = propValues(ms.properties, 'after');
         if (after.length > 0) {
-            const day = Math.max(0, ...after.map(refEndDay));
+            // Milestones disallow inline date literals at the validator
+            // level (rule 24a — milestones already have `date:`). The
+            // shared `resolveAfterDay` helper still handles such input
+            // gracefully if it slips past, treating the date as the
+            // milestone's effective day.
+            const day = Math.max(0, ...after.map(resolveAfterDay));
             if (ms.name) milestoneEnd.set(ms.name, day);
             maxDay = Math.max(maxDay, day);
         }

package/src/nodes/group-node.ts

@@ -14,6 +14,8 @@
 import type { EntityProperty, GroupBlock, ItemDeclaration, ParallelBlock } from '@nowline/core';
 import { isItemDeclaration } from '@nowline/core';
 import { deriveItemDurationDays } from '../calendar.js';
+import { propValues } from '../dsl-utils.js';
+import { computeContainerInlineDatePins, pickInlineDate } from '../inline-date-pin-geometry.js';
 import type { LayoutContext, TrackCursor } from '../layout-context.js';
 import { RowPacker } from '../row-packer.js';
 import { resolveStyle } from '../style-resolution.js';
@@ -240,6 +242,11 @@ export class GroupNode {
             ctx.entityRightEdges.set(id, box.x + box.width);
         }
         ctx.currentFlowKey = previousFlowKey;
+        const inlineDatePins = computeContainerInlineDatePins({
+            box,
+            afterDate: pickInlineDate(propValues(node.properties, 'after')),
+            beforeDate: pickInlineDate(propValues(node.properties, 'before')),
+        });
         return {
             kind: 'group',
             id,
@@ -247,6 +254,7 @@ export class GroupNode {
             box,
             children,
             style,
+            inlineDatePins: inlineDatePins.length > 0 ? inlineDatePins : undefined,
         };
     }
 }

package/src/nodes/parallel-node.ts

@@ -6,6 +6,8 @@
 // helpers in `layout.ts`).
 
 import type { GroupBlock, ItemDeclaration, ParallelBlock } from '@nowline/core';
+import { propValues } from '../dsl-utils.js';
+import { computeContainerInlineDatePins, pickInlineDate } from '../inline-date-pin-geometry.js';
 import type { LayoutContext, TrackCursor } from '../layout-context.js';
 import { resolveStyle } from '../style-resolution.js';
 import { TRACK_BLOCK_TAIL_GUTTER_PX } from '../themes/shared.js';
@@ -89,6 +91,12 @@ export class ParallelNode {
             ctx.entityRightEdges.set(id, box.x + box.width);
         }
 
+        const inlineDatePins = computeContainerInlineDatePins({
+            box,
+            afterDate: pickInlineDate(propValues(node.properties, 'after')),
+            beforeDate: pickInlineDate(propValues(node.properties, 'before')),
+        });
+
         return {
             kind: 'parallel',
             id,
@@ -96,6 +104,7 @@ export class ParallelNode {
             box,
             children,
             style,
+            inlineDatePins: inlineDatePins.length > 0 ? inlineDatePins : undefined,
         };
     }
 }

package/src/types.ts

@@ -223,6 +223,30 @@ export interface PositionedNowline {
     style: ResolvedStyle;
 }
 
+/**
+ * One inline-date pin (`after:DATE` / `before:DATE`) attached to an entity.
+ * The renderer paints a small calendar glyph at `glyphTopLeft` with side
+ * length `glyphSize`, fills with the entity's resolved meta color, and emits
+ * a `<title>` child carrying `isoDate` for native browser tooltips. There is
+ * no inline date caption — see specs/rendering.md "Inline-date glyph".
+ *
+ * `side` decides which corner the glyph belongs in (top-LEFT for `after`,
+ * top-RIGHT for `before`). The validator enforces "at most one inline date
+ * per direction" so `inlineDatePins` carries 0..2 entries.
+ *
+ * `spilled === true` means the entity (item bar) was too narrow to host the
+ * glyph inside its decoration row, so `glyphTopLeft` points at the spill
+ * column outside the bar instead. Group and parallel containers never spill;
+ * they always have room for the glyph in their bounding box.
+ */
+export interface InlineDatePin {
+    side: 'after' | 'before';
+    isoDate: string;
+    glyphTopLeft: Point;
+    glyphSize: number;
+    spilled: boolean;
+}
+
 export interface PositionedItem {
     kind: 'item';
     id?: string;
@@ -232,6 +256,10 @@ export interface PositionedItem {
     progressFraction: number; // 0..1; 1 == fully filled
     footnoteIndicators: number[]; // 1-based superscript numbers, empty when no footnotes
     labelChips: PositionedLabelChip[];
+    /** Inline-date pins attached to this item (`after:DATE` / `before:DATE`).
+     *  Empty (or undefined) when the item has no inline-date pins. See
+     *  `InlineDatePin` and specs/rendering.md "Inline-date glyph". */
+    inlineDatePins?: InlineDatePin[];
     /** True when the chip row's natural total width exceeded the bar's
      *  effective inner width and the whole row spilled past the bar's
      *  right edge. The chips' `box.x` already reflects the spilled
@@ -359,6 +387,9 @@ export interface PositionedGroup {
     box: BoundingBox;
     // Bracket is drawn on the left edge when style.bracket != 'none'.
     children: PositionedTrackChild[];
+    /** Inline-date pins attached to this group (`after:DATE` / `before:DATE`).
+     *  See `InlineDatePin` and specs/rendering.md "Inline-date glyph". */
+    inlineDatePins?: InlineDatePin[];
     style: ResolvedStyle;
 }
 
@@ -368,6 +399,9 @@ export interface PositionedParallel {
     title?: string;
     box: BoundingBox;
     children: PositionedTrackChild[]; // sub-tracks stacked vertically
+    /** Inline-date pins attached to this parallel (`after:DATE` / `before:DATE`).
+     *  See `InlineDatePin` and specs/rendering.md "Inline-date glyph". */
+    inlineDatePins?: InlineDatePin[];
     style: ResolvedStyle;
 }