@nanisoft/prism-ui 0.13.0 → 0.16.0

package/dist/lib/figure.d.ts

@@ -0,0 +1,149 @@
+/**
+ * The arithmetic every Component that draws a figure shares.
+ *
+ * **One copy rather than one per Component.** Two Components in this package draw
+ * labelled marks into a fixed canvas and both have to answer the same three
+ * questions: where a label's ink box is, where a stroke leaving a mark has to stop
+ * before it enters one, and how a caller's own coordinate space is fitted into the
+ * canvas. Two copies of that
+ * arithmetic are two answers to one question, and the disagreement between them is
+ * invisible until a reader puts the two figures side by side and finds that one of
+ * them runs a line through a word. What stays with each Component is the half that
+ * is genuinely its own: the numbers its own drawing uses and the labels it prints.
+ *
+ * **How any of this is reachable from a server Component.** A Component that cannot
+ * measure text still knows a monospaced label's width, because a monospaced face has
+ * one advance width for every character and so a label's width is its character
+ * count. That is a property of the face every label in a figure is set in rather
+ * than of this module, and it is what makes a label's box arithmetic instead of a
+ * measurement. A label set in a proportional face would have no such answer, which
+ * is a limit of the rule rather than of the Component.
+ *
+ * **Two rules these serve, and the second one has a direction clause.** The
+ * legibility floor in DESIGN.md, and the ink-avoidance rule beside it: a stroke
+ * takes the longest stretch of the line between two marks that no label blocks, so a
+ * label a stroke does not run through costs it nothing. Nothing here draws and
+ * nothing here knows a colour, a token or a class name. A geometry helper that
+ * also held an ink would be holding a token, which is the one thing a figure in
+ * this system never does.
+ */
+/** A point in a figure's own coordinate space. */
+export type FigurePoint = {
+    x: number;
+    y: number;
+};
+/** An axis-aligned rectangle in a figure's own coordinate space. */
+export type FigureBox = {
+    l: number;
+    r: number;
+    t: number;
+    b: number;
+};
+/** The two ends of a drawn stroke. */
+export type FigureStroke = {
+    from: FigurePoint;
+    to: FigurePoint;
+};
+/**
+ * One label a Component prints beside a mark, in the three numbers the arithmetic
+ * below reads it by.
+ *
+ * A label is passed as its own text rather than as a measured box because there is
+ * no measurement to pass: the text is the measurement, and the Component that owns
+ * the label is the only one that knows its size and its baseline.
+ */
+export type FigureLabel = {
+    /** The label's own text, whose character count is its width. */
+    text: string;
+    /** Its type size, in user units. */
+    size: number;
+    /** Its baseline, measured down from the mark's centre. */
+    offset: number;
+};
+/**
+ * The canvas a caller's points are fitted into.
+ *
+ * `bottom` is separate from `height` because a figure that draws something along its
+ * foot reserves a band there, and the fitted area stops above that band rather than
+ * the canvas growing to fit both.
+ */
+export type FigureFrame = {
+    width: number;
+    height: number;
+    /** The band left empty on the top and on the two sides. */
+    padding: number;
+    /** The fitted area's lower edge, which defaults to `height - padding`. */
+    bottom?: number;
+};
+/**
+ * The metrics of the face every label in a figure is set in, as fractions of the
+ * type size, and the gap the drawing keeps between one piece of ink and the next.
+ *
+ * A monospaced face has one advance width for every character, so `MONO_ADVANCE` is
+ * what turns a label's character count into a width, and `LABEL_ASCENT` and
+ * `LABEL_DESCENT` are what turn a baseline into a box. The three are the face's own
+ * rather than a decision about any one drawing, and they are a little generous on
+ * purpose: a box wider or deeper than the ink it stands for costs a little length on
+ * a stroke, while a box narrower or shallower costs a word a reader has to guess at.
+ *
+ * `INK_CLEARANCE` is the space the box adds around that ink, so it is both the gap
+ * between a stroke and the label it would otherwise run through and the margin the
+ * box keeps around the mark's own centre line. One constant rather than two because
+ * it is one fact: no two pieces of ink in a figure touch.
+ */
+export declare const MONO_ADVANCE = 0.6;
+export declare const LABEL_ASCENT = 0.8;
+export declare const LABEL_DESCENT = 0.25;
+export declare const INK_CLEARANCE = 7;
+/** Half the width of a monospaced label of `size` user units, in user units. */
+export declare function labelHalfWidth(label: string, size: number): number;
+/** Half the height of a label of `size` user units, in user units. */
+export declare function labelHalfHeight(size: number): number;
+/**
+ * The visible part of a stroke between two marks: the longest stretch of the line
+ * between them that no label blocks, held off each mark by the mark's own clearance.
+ *
+ * **Trim a segment against what it would actually enter, and nothing else.** A label
+ * is an obstacle only where the stroke runs, so each label is its own box and a
+ * stroke that misses it pays nothing for it. A name is printed under its mark and a
+ * note under that, so both sit below it, and a stroke leaving sideways runs along
+ * the mark's own centre line and enters neither. Backing a stroke off the mark by
+ * the half-width of the widest label at the node anyway pushed every connector on a
+ * six-stage rail back by up to fifty units from a six-unit mark: a row of circles
+ * with short line segments floating between them, which is a drawing of a shape and
+ * none of its relations. So the whole rail reaches both of its marks and nothing is
+ * trimmed there at all.
+ *
+ * **The stretch is the one the whole stroke fits in, and not two trims taken one at a
+ * time, because a label can block the corridor behind a mark rather than the mark
+ * itself.** A node's name and note sit below it at two different depths, so a
+ * stroke arriving from below runs through the name, out of it, and then back into the
+ * note further along: stopping where the name ends leaves the stroke sitting on top
+ * of the note. The drawn stroke is what has to be clear, so the whole line between
+ * the two marks is divided once and the longest unblocked stretch of it is drawn.
+ *
+ * **A mark's own edge plus the clearance is where an end sits when nothing blocks
+ * it.** A mark is a circle, so its edge is `mark` away in every direction, and the
+ * clearance is the gap that holds a stroke off the ink it belongs to. A line with no
+ * label on it therefore starts one clearance from the first mark and ends one
+ * clearance from the second, and that pair is the whole of what a stroke leaving a
+ * node sideways is allowed to cost.
+ *
+ * Two blocked stretches can leave nothing between them when a caller puts two marks
+ * close together, and a line trimmed away entirely is a line that silently did not
+ * draw, which is the one failure a figure in this package exists to make impossible.
+ * The mark boundaries are then the shortest stroke that still joins the two marks,
+ * and a caller who has put two marks on top of one another has already been told what
+ * that draws.
+ */
+export declare function strokeBetween(from: FigurePoint, to: FigurePoint, mark: number, fromLabels: readonly FigureLabel[], toLabels: readonly FigureLabel[]): FigureStroke;
+/**
+ * The caller's points, fitted into the frame with their aspect ratio kept and the
+ * leftover shared out evenly.
+ *
+ * A caller whose points span one axis only, or who passes one item, gets the other
+ * axis centred rather than a division by zero: the scale is taken over the axes that
+ * have an extent, and a figure with no extent at all keeps the caller's own numbers.
+ */
+export declare function fitPoints<T extends FigurePoint>(items: readonly T[], frame: FigureFrame): (item: T) => FigurePoint;
+//# sourceMappingURL=figure.d.ts.map

package/dist/lib/figure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"figure.d.ts","sourceRoot":"","sources":["../../src/lib/figure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,kDAAkD;AAClD,MAAM,MAAM,WAAW,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAElD,oEAAoE;AACpE,MAAM,MAAM,SAAS,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtE,sCAAsC;AACtC,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,WAAW,CAAA;CAAE,CAAA;AAKjE;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAA;IACZ,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,0DAA0D;IAC1D,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAA;IACf,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,MAAM,CAAA;AAC/B,eAAO,MAAM,YAAY,MAAM,CAAA;AAC/B,eAAO,MAAM,aAAa,OAAO,CAAA;AACjC,eAAO,MAAM,aAAa,IAAI,CAAA;AAE9B,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAElE;AAED,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpD;AAiGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,WAAW,EACjB,EAAE,EAAE,WAAW,EACf,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,SAAS,WAAW,EAAE,EAClC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAC/B,YAAY,CAgCd;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,WAAW,EAC7C,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,KAAK,EAAE,WAAW,GACjB,CAAC,IAAI,EAAE,CAAC,KAAK,WAAW,CAyB1B"}

package/dist/lib/figure.js

@@ -0,0 +1,242 @@
+/**
+ * The arithmetic every Component that draws a figure shares.
+ *
+ * **One copy rather than one per Component.** Two Components in this package draw
+ * labelled marks into a fixed canvas and both have to answer the same three
+ * questions: where a label's ink box is, where a stroke leaving a mark has to stop
+ * before it enters one, and how a caller's own coordinate space is fitted into the
+ * canvas. Two copies of that
+ * arithmetic are two answers to one question, and the disagreement between them is
+ * invisible until a reader puts the two figures side by side and finds that one of
+ * them runs a line through a word. What stays with each Component is the half that
+ * is genuinely its own: the numbers its own drawing uses and the labels it prints.
+ *
+ * **How any of this is reachable from a server Component.** A Component that cannot
+ * measure text still knows a monospaced label's width, because a monospaced face has
+ * one advance width for every character and so a label's width is its character
+ * count. That is a property of the face every label in a figure is set in rather
+ * than of this module, and it is what makes a label's box arithmetic instead of a
+ * measurement. A label set in a proportional face would have no such answer, which
+ * is a limit of the rule rather than of the Component.
+ *
+ * **Two rules these serve, and the second one has a direction clause.** The
+ * legibility floor in DESIGN.md, and the ink-avoidance rule beside it: a stroke
+ * takes the longest stretch of the line between two marks that no label blocks, so a
+ * label a stroke does not run through costs it nothing. Nothing here draws and
+ * nothing here knows a colour, a token or a class name. A geometry helper that
+ * also held an ink would be holding a token, which is the one thing a figure in
+ * this system never does.
+ */
+/**
+ * The metrics of the face every label in a figure is set in, as fractions of the
+ * type size, and the gap the drawing keeps between one piece of ink and the next.
+ *
+ * A monospaced face has one advance width for every character, so `MONO_ADVANCE` is
+ * what turns a label's character count into a width, and `LABEL_ASCENT` and
+ * `LABEL_DESCENT` are what turn a baseline into a box. The three are the face's own
+ * rather than a decision about any one drawing, and they are a little generous on
+ * purpose: a box wider or deeper than the ink it stands for costs a little length on
+ * a stroke, while a box narrower or shallower costs a word a reader has to guess at.
+ *
+ * `INK_CLEARANCE` is the space the box adds around that ink, so it is both the gap
+ * between a stroke and the label it would otherwise run through and the margin the
+ * box keeps around the mark's own centre line. One constant rather than two because
+ * it is one fact: no two pieces of ink in a figure touch.
+ */
+export const MONO_ADVANCE = 0.6;
+export const LABEL_ASCENT = 0.8;
+export const LABEL_DESCENT = 0.25;
+export const INK_CLEARANCE = 7;
+/** Half the width of a monospaced label of `size` user units, in user units. */
+export function labelHalfWidth(label, size) {
+    return (label.length * MONO_ADVANCE * size) / 2;
+}
+/** Half the height of a label of `size` user units, in user units. */
+export function labelHalfHeight(size) {
+    return ((LABEL_ASCENT + LABEL_DESCENT) * size) / 2;
+}
+/**
+ * The box one label's ink occupies, with the clearance around it.
+ *
+ * One label rather than a node's whole set of them, and that is the whole of the
+ * trim rule: a stroke is stopped by the labels it would actually enter, so the
+ * clearance around one label has to be findable on its own rather than only as
+ * part of a rectangle enclosing all of them.
+ */
+function labelBox(at, label) {
+    const half = labelHalfWidth(label.text, label.size);
+    return {
+        l: at.x - half - INK_CLEARANCE,
+        r: at.x + half + INK_CLEARANCE,
+        t: at.y + label.offset - LABEL_ASCENT * label.size - INK_CLEARANCE,
+        b: at.y + label.offset + LABEL_DESCENT * label.size + INK_CLEARANCE,
+    };
+}
+/**
+ * The stretch of a ray that is inside one box, measured as a distance along the ray
+ * from where it starts, or `null` for a ray that misses it.
+ *
+ * The two axes are taken separately and intersected, so a ray running exactly along
+ * an axis is not a division by zero and a ray that clips a corner enters and leaves
+ * in the same place rather than entering at all.
+ */
+function raySpan(from, toward, box) {
+    const length = Math.hypot(toward.x - from.x, toward.y - from.y);
+    if (length === 0)
+        return null;
+    const ux = (toward.x - from.x) / length;
+    const uy = (toward.y - from.y) / length;
+    let enter = 0;
+    let leave = Number.POSITIVE_INFINITY;
+    for (const [origin, delta, low, high] of [
+        [from.x, ux, box.l, box.r],
+        [from.y, uy, box.t, box.b],
+    ]) {
+        if (delta === 0) {
+            if (origin < low || origin > high)
+                return null;
+            continue;
+        }
+        const near = (low - origin) / delta;
+        const far = (high - origin) / delta;
+        enter = Math.max(enter, Math.min(near, far));
+        leave = Math.min(leave, Math.max(near, far));
+        if (enter > leave)
+            return null;
+    }
+    return { enter, leave };
+}
+/**
+ * The stretches of the line between two marks that no label's clearance blocks, in
+ * order along it and with the two marks themselves as its ends.
+ *
+ * Two of the boxes a caller hands over can block the same stretch, and one box can
+ * block two, so the stretches are merged before they are compared: the answer is a
+ * set of gaps rather than a set of obstacles, and a gap that counted twice would be
+ * a gap that won twice.
+ */
+function freeStretches(from, to, boxes) {
+    const length = Math.hypot(to.x - from.x, to.y - from.y);
+    const blocked = boxes
+        .map((box) => raySpan(from, to, box))
+        .filter((span) => span !== null)
+        .map((span) => ({
+        enter: Math.max(0, span.enter),
+        leave: Math.min(length, span.leave),
+    }))
+        .filter((span) => span.leave > span.enter)
+        .sort((a, b) => a.enter - b.enter);
+    const merged = [];
+    for (const span of blocked) {
+        const open = merged[merged.length - 1];
+        if (open && span.enter <= open.leave) {
+            open.leave = Math.max(open.leave, span.leave);
+        }
+        else {
+            merged.push({ ...span });
+        }
+    }
+    const gaps = [];
+    let walked = 0;
+    for (const span of merged) {
+        if (span.enter > walked)
+            gaps.push({ enter: walked, leave: span.enter });
+        walked = span.leave;
+    }
+    gaps.push({ enter: walked, leave: length });
+    return gaps;
+}
+/**
+ * The visible part of a stroke between two marks: the longest stretch of the line
+ * between them that no label blocks, held off each mark by the mark's own clearance.
+ *
+ * **Trim a segment against what it would actually enter, and nothing else.** A label
+ * is an obstacle only where the stroke runs, so each label is its own box and a
+ * stroke that misses it pays nothing for it. A name is printed under its mark and a
+ * note under that, so both sit below it, and a stroke leaving sideways runs along
+ * the mark's own centre line and enters neither. Backing a stroke off the mark by
+ * the half-width of the widest label at the node anyway pushed every connector on a
+ * six-stage rail back by up to fifty units from a six-unit mark: a row of circles
+ * with short line segments floating between them, which is a drawing of a shape and
+ * none of its relations. So the whole rail reaches both of its marks and nothing is
+ * trimmed there at all.
+ *
+ * **The stretch is the one the whole stroke fits in, and not two trims taken one at a
+ * time, because a label can block the corridor behind a mark rather than the mark
+ * itself.** A node's name and note sit below it at two different depths, so a
+ * stroke arriving from below runs through the name, out of it, and then back into the
+ * note further along: stopping where the name ends leaves the stroke sitting on top
+ * of the note. The drawn stroke is what has to be clear, so the whole line between
+ * the two marks is divided once and the longest unblocked stretch of it is drawn.
+ *
+ * **A mark's own edge plus the clearance is where an end sits when nothing blocks
+ * it.** A mark is a circle, so its edge is `mark` away in every direction, and the
+ * clearance is the gap that holds a stroke off the ink it belongs to. A line with no
+ * label on it therefore starts one clearance from the first mark and ends one
+ * clearance from the second, and that pair is the whole of what a stroke leaving a
+ * node sideways is allowed to cost.
+ *
+ * Two blocked stretches can leave nothing between them when a caller puts two marks
+ * close together, and a line trimmed away entirely is a line that silently did not
+ * draw, which is the one failure a figure in this package exists to make impossible.
+ * The mark boundaries are then the shortest stroke that still joins the two marks,
+ * and a caller who has put two marks on top of one another has already been told what
+ * that draws.
+ */
+export function strokeBetween(from, to, mark, fromLabels, toLabels) {
+    const dx = to.x - from.x;
+    const dy = to.y - from.y;
+    const length = Math.hypot(dx, dy);
+    if (length === 0)
+        return { from, to };
+    const ux = dx / length;
+    const uy = dy / length;
+    // Both nodes' labels, in one list, because the corridor between the marks is one
+    // corridor and a label of either end can be what blocks it. Each label is anchored
+    // to the mark it is printed under, which for one of them is not where this line
+    // starts.
+    const gaps = freeStretches(from, to, [
+        ...fromLabels.map((label) => labelBox(from, label)),
+        ...toLabels.map((label) => labelBox(to, label)),
+    ]);
+    const room = gaps.reduce((best, gap) => gap.leave - gap.enter > best.leave - best.enter ? gap : best);
+    const head = Math.max(room.enter, mark + INK_CLEARANCE);
+    const tail = Math.min(room.leave, length - mark - INK_CLEARANCE);
+    if (tail > head) {
+        return {
+            from: { x: from.x + ux * head, y: from.y + uy * head },
+            to: { x: from.x + ux * tail, y: from.y + uy * tail },
+        };
+    }
+    return {
+        from: { x: from.x + ux * mark, y: from.y + uy * mark },
+        to: { x: to.x - ux * mark, y: to.y - uy * mark },
+    };
+}
+/**
+ * The caller's points, fitted into the frame with their aspect ratio kept and the
+ * leftover shared out evenly.
+ *
+ * A caller whose points span one axis only, or who passes one item, gets the other
+ * axis centred rather than a division by zero: the scale is taken over the axes that
+ * have an extent, and a figure with no extent at all keeps the caller's own numbers.
+ */
+export function fitPoints(items, frame) {
+    const bottom = frame.bottom ?? frame.height - frame.padding;
+    if (items.length === 0) {
+        return () => ({ x: frame.width / 2, y: (frame.padding + bottom) / 2 });
+    }
+    const xs = items.map((item) => item.x);
+    const ys = items.map((item) => item.y);
+    const minX = Math.min(...xs);
+    const minY = Math.min(...ys);
+    const spanX = Math.max(...xs) - minX;
+    const spanY = Math.max(...ys) - minY;
+    const roomX = frame.width - frame.padding * 2;
+    const roomY = bottom - frame.padding;
+    const scale = Math.min(spanX === 0 ? Number.POSITIVE_INFINITY : roomX / spanX, spanY === 0 ? Number.POSITIVE_INFINITY : roomY / spanY);
+    const unit = Number.isFinite(scale) && scale > 0 ? scale : 1;
+    const offsetX = frame.padding + (roomX - spanX * unit) / 2 - minX * unit;
+    const offsetY = frame.padding + (roomY - spanY * unit) / 2 - minY * unit;
+    return (item) => ({ x: item.x * unit + offsetX, y: item.y * unit + offsetY });
+}

package/dist/lib/utils.d.ts

@@ -1,3 +1,32 @@
 import { type ClassValue } from 'clsx';
 export declare function cn(...inputs: ClassValue[]): string;
+/**
+ * The calendar day a moment falls on, as a `YYYY-MM-DD` key.
+ *
+ * **This is here rather than in three Blocks because three Blocks needed it and
+ * the fourth would have been the argument.** `activity-feed-01`, `audit-log-01`
+ * and `calendar-01` each grew their own copy while the roster was being authored,
+ * each with its own three-line JSDoc saying the duplication was a decision and
+ * naming this file as the right home. Three copies of a five-line function that
+ * computes a date are three places a bug would be fixed once and stay broken
+ * twice, so this module holds the one and the three Blocks import it.
+ *
+ * `lib/utils.ts` is the file every registry item already ships beside itself, so
+ * the shared implementation needs no new path in the generated registry and no
+ * new entry for a consumer to resolve. That is why the helper is here and not in
+ * a second `lib` module.
+ *
+ * **The day is the runtime's, not the reader's**, and the JSDoc on each of the
+ * three Blocks says what to do about that: a consumer whose records are grouped
+ * by a named zone groups them itself and passes one entry per group with grouping
+ * off. Prism ships no calendar, and a Block cannot pick the reader's zone without
+ * a prop that would be a guess dressed as a setting. A caller who needs a
+ * particular zone composes `Intl.DateTimeFormat` with one and passes the key.
+ *
+ * Accepts the same three shapes the Blocks pass: epoch milliseconds, a `Date`,
+ * and a date string. A string that is not parseable returns an empty key rather
+ * than throwing, because the Blocks treat an absent key as a moment with no group
+ * and a throw would take a whole record list down over one bad row.
+ */
+export declare function dayKey(at: number | string | Date): string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAQ,MAAM,MAAM,CAAA;AAG5C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAQ,MAAM,MAAM,CAAA;AAG5C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,CAKzD"}

package/dist/lib/utils.js

@@ -3,3 +3,38 @@ import { twMerge } from 'tailwind-merge';
 export function cn(...inputs) {
     return twMerge(clsx(inputs));
 }
+/**
+ * The calendar day a moment falls on, as a `YYYY-MM-DD` key.
+ *
+ * **This is here rather than in three Blocks because three Blocks needed it and
+ * the fourth would have been the argument.** `activity-feed-01`, `audit-log-01`
+ * and `calendar-01` each grew their own copy while the roster was being authored,
+ * each with its own three-line JSDoc saying the duplication was a decision and
+ * naming this file as the right home. Three copies of a five-line function that
+ * computes a date are three places a bug would be fixed once and stay broken
+ * twice, so this module holds the one and the three Blocks import it.
+ *
+ * `lib/utils.ts` is the file every registry item already ships beside itself, so
+ * the shared implementation needs no new path in the generated registry and no
+ * new entry for a consumer to resolve. That is why the helper is here and not in
+ * a second `lib` module.
+ *
+ * **The day is the runtime's, not the reader's**, and the JSDoc on each of the
+ * three Blocks says what to do about that: a consumer whose records are grouped
+ * by a named zone groups them itself and passes one entry per group with grouping
+ * off. Prism ships no calendar, and a Block cannot pick the reader's zone without
+ * a prop that would be a guess dressed as a setting. A caller who needs a
+ * particular zone composes `Intl.DateTimeFormat` with one and passes the key.
+ *
+ * Accepts the same three shapes the Blocks pass: epoch milliseconds, a `Date`,
+ * and a date string. A string that is not parseable returns an empty key rather
+ * than throwing, because the Blocks treat an absent key as a moment with no group
+ * and a throw would take a whole record list down over one bad row.
+ */
+export function dayKey(at) {
+    const date = at instanceof Date ? at : new Date(at);
+    if (Number.isNaN(date.getTime()))
+        return '';
+    const two = (value) => String(value).padStart(2, '0');
+    return `${date.getFullYear()}-${two(date.getMonth() + 1)}-${two(date.getDate())}`;
+}

package/dist/live/index.d.ts

@@ -7,9 +7,14 @@
  * changes on its own, which no amount of prop-passing expresses.
  *
  * The `-NN` suffix is the live-family variant ordinal, as it is for Blocks and
- * Pages. These are the only client Components Prism ships, and they are client
- * because of what they are rather than as an accident: a surface that receives
- * events owns the subscription that delivers them.
+ * Pages. They are client Components because of what they are rather than as an
+ * accident: a surface that receives events owns the subscription that delivers
+ * them. That is not the same as being the only client code in the package, which
+ * this file used to claim and which stopped being true when the roster grew
+ * Blocks and a Page that hold a handler. The claim that still holds, and is the
+ * one worth keeping, is narrower: **a live surface is the only Item Prism ships
+ * that receives its own content over a subscription rather than being handed it
+ * as props.**
  *
  * **Nothing here opens a connection.** A live surface takes a `subscribe` function
  * the consumer supplies and a function it tears down, so Prism owns no socket, no
@@ -19,4 +24,6 @@
  */
 export { RunStream01 } from './run-stream-01/index.js';
 export type { RunStream01Props, RunEvent, RunEventRole, RunStatus, RunSubscribe, } from './run-stream-01/index.js';
+export { ToolLedger01 } from './tool-ledger-01/index.js';
+export type { ToolLedger01Props, ToolCall, ToolCallState, ToolSubscribe } from './tool-ledger-01/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/live/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/live/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC7C,YAAY,EACV,gBAAgB,EAChB,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,YAAY,GACb,MAAM,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/live/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC7C,YAAY,EACV,gBAAgB,EAChB,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,YAAY,GACb,MAAM,iBAAiB,CAAA;AAMxB,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,YAAY,EAAE,iBAAiB,EAAE,QAAQ,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/live/index.js

@@ -7,9 +7,14 @@
  * changes on its own, which no amount of prop-passing expresses.
  *
  * The `-NN` suffix is the live-family variant ordinal, as it is for Blocks and
- * Pages. These are the only client Components Prism ships, and they are client
- * because of what they are rather than as an accident: a surface that receives
- * events owns the subscription that delivers them.
+ * Pages. They are client Components because of what they are rather than as an
+ * accident: a surface that receives events owns the subscription that delivers
+ * them. That is not the same as being the only client code in the package, which
+ * this file used to claim and which stopped being true when the roster grew
+ * Blocks and a Page that hold a handler. The claim that still holds, and is the
+ * one worth keeping, is narrower: **a live surface is the only Item Prism ships
+ * that receives its own content over a subscription rather than being handed it
+ * as props.**
  *
  * **Nothing here opens a connection.** A live surface takes a `subscribe` function
  * the consumer supplies and a function it tears down, so Prism owns no socket, no
@@ -18,3 +23,7 @@
  * that boundary is stated once.
  */
 export { RunStream01 } from './run-stream-01/index.js';
+/*
+ * Derived by the maintainer rather than authored: each entry is read out of the Item own
+ * index module, so an Item and its barrel line cannot come apart. */
+export { ToolLedger01 } from './tool-ledger-01/index.js';

package/dist/live/run-stream-01/run-stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run-stream.d.ts","sourceRoot":"","sources":["../../../src/live/run-stream-01/run-stream.tsx"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAA;AAEhE,6CAA6C;AAC7C,MAAM,MAAM,QAAQ,GAAG;IACrB,2FAA2F;IAC3F,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,YAAY,CAAA;IAClB,qEAAqE;IACrE,EAAE,EAAE,MAAM,CAAA;IACV,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAA;IACf,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,6FAA6F;AAC7F,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAA;AAE5E;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,KAAK,MAAM,IAAI,CAAA;AAE1E,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;OAIG;IACH,SAAS,EAAE,YAAY,CAAA;IACvB;;;;;;;;;OASG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAChC;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC7B,gCAAgC;IAChC,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mFAAmF;IACnF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,8CAA8C;IAC9C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;;;;OAOG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AA8BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,WAAW,CAAC,EAC1B,SAAS,EACT,cAAc,EACd,OAAO,EACP,MAAM,EACN,WAAW,EACX,OAAO,EACP,KAAK,EACL,WAAW,EACX,UAAU,EACV,WAAW,EACX,SAAS,EACT,KAAW,EACX,SAAS,GACV,EAAE,gBAAgB,+BA8HlB;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"run-stream.d.ts","sourceRoot":"","sources":["../../../src/live/run-stream-01/run-stream.tsx"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAA;AAEhE,6CAA6C;AAC7C,MAAM,MAAM,QAAQ,GAAG;IACrB,2FAA2F;IAC3F,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,YAAY,CAAA;IAClB,qEAAqE;IACrE,EAAE,EAAE,MAAM,CAAA;IACV,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAA;IACf,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,6FAA6F;AAC7F,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAA;AAE5E;;;;;;;;GAQG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,KAAK,MAAM,IAAI,CAAA;AAE1E,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;OAIG;IACH,SAAS,EAAE,YAAY,CAAA;IACvB;;;;;;;;;OASG;IACH,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAChC;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC7B,gCAAgC;IAChC,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,oEAAoE;IACpE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mFAAmF;IACnF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,8CAA8C;IAC9C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;;;;OAOG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AA8BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,WAAW,CAAC,EAC1B,SAAS,EACT,cAAc,EACd,OAAO,EACP,MAAM,EACN,WAAW,EACX,OAAO,EACP,KAAK,EACL,WAAW,EACX,UAAU,EACV,WAAW,EACX,SAAS,EACT,KAAW,EACX,SAAS,GACV,EAAE,gBAAgB,+BA0IlB;AAED,eAAe,WAAW,CAAA"}

package/dist/live/run-stream-01/run-stream.js

@@ -3,6 +3,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
 import { LiveRegion } from '../../components/ui/live-region.js';
 import { ScrollArea } from '../../components/ui/scroll-area.js';
+import { headingSizeClass } from '../../components/ui/section.js';
 import { cn } from '../../lib/utils.js';
 /** The ink each role is stated in, and the tick beside it. */
 const ROLE_INK = {
@@ -13,10 +14,10 @@ const ROLE_INK = {
 };
 /** The tick each role draws, so the four are told apart without relying on colour. */
 const ROLE_MARK = {
-    agent: '●',
-    tool: 'â–¸',
-    system: '·',
-    error: '×',
+    agent: '●',
+    tool: '▸',
+    system: '·',
+    error: '×',
 };
 const STATUS_INK = {
     queued: 'text-muted-foreground',
@@ -106,6 +107,6 @@ export function RunStream01({ subscribe, resubscribeKey, initial, status, status
                 stop();
         };
     }, [subscribe, resubscribeKey, limit]);
-    return (_jsxs("section", { "data-slot": "run-stream", className: cn('border-border flex flex-col gap-4 rounded-lg border p-4', className), children: [LiveRegion({ politeness: 'polite', label: liveLabel, children: newest }), title !== undefined || eyebrow !== undefined || description !== undefined ? (_jsxs("header", { className: "flex flex-col gap-1", children: [eyebrow ? (_jsx("span", { className: "text-muted-foreground text-xs font-medium tracking-wide uppercase", children: eyebrow })) : null, title ? _jsx("h2", { className: "text-lg font-semibold tracking-tight", children: title }) : null, description ? (_jsx("p", { className: "text-muted-foreground text-pretty text-sm", children: description })) : null] })) : null, status !== undefined ? (_jsx("p", { "data-slot": "run-status", className: cn('font-mono text-xs', STATUS_INK[status]), children: statusLabel })) : null, events.length === 0 ? (_jsx("p", { "data-slot": "run-stream-empty", className: "text-muted-foreground text-sm", children: emptyLabel })) : (_jsx(ScrollArea, { label: eventsLabel, className: "max-h-80", children: _jsx("ol", { "data-slot": "run-events", className: "flex flex-col gap-2", children: events.map((event) => (_jsxs("li", { "data-slot": "run-event", "data-role": event.role, className: "grid grid-cols-[auto_auto_1fr] items-baseline gap-x-3 gap-y-0.5", children: [_jsx("span", { "aria-hidden": "true", className: cn('font-mono text-xs', ROLE_INK[event.role]), children: ROLE_MARK[event.role] }), _jsx("time", { dateTime: new Date(event.at).toISOString(), className: "text-muted-foreground font-mono text-xs tabular-nums", children: new Date(event.at).toISOString().slice(11, 19) }), _jsxs("span", { className: cn('text-pretty text-sm', ROLE_INK[event.role]), children: [event.message, event.detail ? (_jsx("span", { className: "text-muted-foreground block font-mono text-xs", children: event.detail })) : null] })] }, event.id))) }) }))] }));
+    return (_jsxs("section", { "data-slot": "run-stream", className: cn('border-border flex flex-col gap-4 rounded-lg border p-4', className), children: [LiveRegion({ politeness: 'polite', label: liveLabel, children: newest }), title !== undefined || eyebrow !== undefined || description !== undefined ? (_jsxs("header", { className: "flex flex-col gap-1", children: [eyebrow ? (_jsx("span", { className: "text-muted-foreground text-xs font-medium tracking-wide uppercase", children: eyebrow })) : null, title ? _jsx("h2", { className: cn('font-semibold tracking-tight text-balance', headingSizeClass('h2')), children: title }) : null, description ? (_jsx("p", { className: "text-muted-foreground text-pretty text-sm", children: description })) : null] })) : null, status !== undefined ? (_jsx("p", { "data-slot": "run-status", className: cn('font-mono text-xs', STATUS_INK[status]), children: statusLabel })) : null, events.length === 0 ? (_jsx("p", { "data-slot": "run-stream-empty", className: "text-muted-foreground text-sm", children: emptyLabel })) : (_jsx(ScrollArea, { label: eventsLabel, className: "max-h-80", children: _jsx("ol", { "data-slot": "run-events", className: "flex flex-col gap-2", children: events.map((event) => (_jsxs("li", { "data-slot": "run-event", "data-role": event.role, className: "grid grid-cols-[auto_auto_1fr] items-baseline gap-x-3 gap-y-0.5", children: [_jsx("span", { "aria-hidden": "true", className: cn('font-mono text-xs', ROLE_INK[event.role]), children: ROLE_MARK[event.role] }), _jsx("time", { dateTime: new Date(event.at).toISOString(), className: "text-muted-foreground font-mono text-xs tabular-nums", children: new Date(event.at).toISOString().slice(11, 19) }), _jsxs("span", { className: cn('text-pretty text-sm', ROLE_INK[event.role]), children: [event.message, event.detail ? (_jsx("span", { className: "text-muted-foreground block font-mono text-xs", children: event.detail })) : null] })] }, event.id))) }) }))] }));
 }
 export default RunStream01;

package/dist/live/tool-ledger-01/index.d.ts

@@ -0,0 +1,3 @@
+export { ToolLedger01, default } from './tool-ledger.js';
+export type { ToolLedger01Props, ToolCall, ToolCallState, ToolSubscribe, } from './tool-ledger.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/live/tool-ledger-01/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/live/tool-ledger-01/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACrD,YAAY,EACV,iBAAiB,EACjB,QAAQ,EACR,aAAa,EACb,aAAa,GACd,MAAM,eAAe,CAAA"}

package/dist/live/tool-ledger-01/index.js

@@ -0,0 +1 @@
+export { ToolLedger01, default } from './tool-ledger.js';