@danxbot/ui 1.0.0

package/dist/types/index.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Danxbot — public library surface.
+ *
+ * This single entry is the contract for BOTH build targets: the ESM package
+ * that applications import, and the compiled global bundle that Claude Design
+ * loads. A component that is not exported here exists in neither.
+ *
+ * Every props interface is named `<Name>Props` — the design agent reads those
+ * type names directly, and consumers get predictable imports.
+ */
+import "./styles/index.css";
+export { Icon, type IconProps, type IconSize, type IconName } from "./components/Icon";
+export { registerIcon, registerIcons, getIcon, hasIcon, iconNames, type IconNode, type IconNodeChild, } from "./lib/icons";
+export { coreIcons, type CoreIconName } from "./icons/data";
+export { Button, buttonVariants, type ButtonProps } from "./components/Button";
+export { Badge, badgeVariants, type BadgeProps } from "./components/Badge";
+export { Spinner, type SpinnerProps } from "./components/Spinner";
+export { Skeleton, SkeletonText, LoadingOverlay, type SkeletonProps, type SkeletonTextProps, type LoadingOverlayProps, } from "./components/Loading";
+export { ErrorBoundary } from "./components/ErrorBoundary";
+export { Field, FieldSet, type FieldProps, type FieldSetProps } from "./components/Field";
+export { Input, Textarea, type InputProps, type TextareaProps } from "./components/Input";
+export { Checkbox, Switch, Radio, RadioGroup, CheckboxField, SwitchField, RadioField, RadioCard, type CheckboxProps, type SwitchProps, type RadioProps, type RadioGroupProps, type CheckboxFieldProps, type SwitchFieldProps, type RadioFieldProps, type RadioCardProps, } from "./components/Choice";
+export { Dialog, DialogClose, AlertDialog, type DialogProps, type AlertDialogProps, } from "./components/Dialog";
+export { Popover, PopoverClose, Tooltip, TooltipProvider, type PopoverProps, type TooltipProps, } from "./components/Popover";
+export { Toaster, ToastProvider, useToast, type ToasterProps, type ToastProviderProps, type ToastOptions, type ToastTone, } from "./components/Toast";
+export { Menu, MenuItem, MenuGroup, MenuRadioGroup, MenuRadioItem, MenuSeparator, type MenuProps, type MenuItemProps, type MenuGroupProps, type MenuRadioGroupProps, type MenuRadioItemProps, } from "./components/Menu";
+export { ThemeMenu, type ThemeMenuProps } from "./components/ThemeMenu";
+export { AppShell, type AppShellProps, type NavItem, type NavSection, } from "./components/AppShell";
+export { FileUpload, type FileUploadProps, type UploadFile } from "./components/FileUpload";
+export { DatePicker, type DatePickerProps, type DateRange } from "./components/DatePicker";
+export { Tree, type TreeProps, type TreeNode } from "./components/Tree";
+export { CommandPalette, useCommandPalette, type CommandPaletteProps, type CommandItem, } from "./components/CommandPalette";
+export { Slider, type SliderProps, type SliderMark } from "./components/Slider";
+export { NumberInput, type NumberInputProps } from "./components/NumberInput";
+export { OTPInput, type OTPInputProps } from "./components/OTPInput";
+export { Combobox, ComboboxItem, ComboboxGroup, MultiCombobox, type ComboboxProps, type ComboboxItemProps, type ComboboxGroupProps, type MultiComboboxProps, } from "./components/Combobox";
+export { Select, SelectItem, SelectGroup, SelectSeparator, type SelectProps, type SelectItemProps, type SelectGroupProps, } from "./components/Select";
+export { StatusSelect, type StatusSelectProps, type StatusOption } from "./components/StatusSelect";
+export { Card, CardHeader, CardFooter, type CardProps, type CardHeaderProps, } from "./components/Card";
+export { Tabs, TabList, Tab, TabPanel, type TabsProps, type TabListProps, type TabProps, type TabPanelProps, } from "./components/Tabs";
+export { Accordion, AccordionItem, type AccordionProps, type AccordionItemProps, } from "./components/Accordion";
+export { Breadcrumb, Pagination, type BreadcrumbProps, type PaginationProps, type Crumb, } from "./components/Navigation";
+export { Toggle, ToggleGroup, Toolbar, ToolbarSeparator, type ToggleProps, type ToggleGroupProps, type ToolbarProps, } from "./components/Toggle";
+export { Separator, ScrollArea, Collapsible, EmptyState, Timeline, type SeparatorProps, type ScrollAreaProps, type CollapsibleProps, type EmptyStateProps, type TimelineProps, type TimelineItem, } from "./components/Surface";
+export { PanelGroup, Panel, PanelResizer, type PanelGroupProps, type PanelProps, type PanelResizerProps, type PanelDirection, type PanelNarrowMode, } from "./components/Panel";
+export { Avatar, AvatarGroup, type AvatarProps, type AvatarGroupProps, type AvatarStatus, } from "./components/Avatar";
+export { Progress, Meter, ProgressRing, type ProgressProps, type MeterProps, type ProgressRingProps, } from "./components/Progress";
+export { Stat, Sparkline, type StatProps, type SparklineProps, type StatTrend, type StatSentiment, } from "./components/Stat";
+export { DataTable, TableEmptyState, CellStack, type DataTableProps, type TableDensity, } from "./components/Table";
+export { CodeEditor, CodeEditorToolbar, CodeEditorCaption, CodeEditorCopyButton, CodeEditorWrapToggle, CodeEditorViewSwitch, type CodeEditorProps, type CodeEditorToolbarProps, type CodeEditorView, } from "./components/CodeEditor";
+export { MarkdownEditor, type MarkdownEditorProps } from "./components/MarkdownEditor";
+export { MarkdownSurface, type SurfaceOptions, type Splice } from "./lib/markdown/surface";
+export { project, projectedText, ProjectionError } from "./lib/markdown/project";
+export type { Projection, PNode, PText, PElement } from "./lib/markdown/project";
+export { attachInput, type InputOptions } from "./lib/markdown/input";
+export { HOTKEYS, hotkeyFor, chordsOf, type Hotkey, type HotkeyGroup } from "./lib/markdown/hotkeys";
+export { htmlFragmentToMarkdown } from "./lib/markdown/paste";
+export { lineAt, stepOffset } from "./lib/markdown/caret";
+export { caretMap, nearestStop, stepStop, graphemeBefore, graphemeAfter, lineStartStop, type CaretMap, } from "./lib/markdown/caret-map";
+export { deleteVisible, deleteVisibleBefore, deleteVisibleAfter } from "./lib/markdown/edit";
+export { resolveKey, type KeyIntent, type KeyContext } from "./lib/markdown/keys";
+export { blockAt, convertBlock, setFenceLanguage, constructAt, editConstruct, unwrapConstruct, type BlockKind, type BlockInfo, type ConstructInfo, } from "./lib/markdown/convert";
+export { readSelection, writeSelection, sourceOffsetAt, domPointAt, type SourceSelection, type DomPoint, type Association, } from "./lib/markdown/position";
+export type { Command, Edit } from "./lib/markdown/commands";
+export { toggleBold, toggleItalic, toggleCode, toggleStrike, toggleInline, setHeading, adjustHeading, headingLevel, toggleList, toggleTask, indentLines, outdentLines, toggleQuote, toggleCodeBlock, fenceAround, insertRule, insertImage, insertLink, insertTable, insertRow, insertColumn, deleteRow, deleteColumn, deleteTable, alignColumn, tableAround, cellsOf, cellAt, tableTab, smartEnter, smartTab, smartShiftTab, } from "./lib/markdown/commands";
+export { tokenize, listLanguages, resolveLanguage, defineGrammar, registerGrammar, checkCoverage, type Token, type TokenType, type Grammar, type Rule, } from "./lib/syntax";
+export { parseMarkdown, MarkdownNodes, sanitizeHref, type MdNode, type MdInline, type MdCodeRenderer, } from "./lib/syntax/markdown";
+export { DragDrop, DragDropContainer, DragDropItem, DragDropHandle, DragDropOverlay, type DragDropProps, type DragDropContainerProps, type DragDropItemProps, type DragDropHandleProps, type DragDropOverlayProps, } from "./components/DragDrop";
+export { DEFAULT_DRAG_STRINGS, DRAG_INSTRUCTIONS_ID, DragInstructions, DragLiveRegion, DragSession, DragSessionProvider, applyMove, attachAutoScroll, attachKeyboardSensor, attachPointerSensor, attachSessionWindowListeners, isNoOp, resolveTarget, sameTarget, scrollVelocity, useCreateDragSession, useDragAnnouncements, useDragSession, useDragState, useDraggable, useDropContainer, type ContainerId, type DragAxis, type DragCancelEvent, type DragEndEvent, type DragId, type DragMode, type DragPhase, type DragSessionCallbacks, type DragStartEvent, type DragState, type AutoScrollOptions, type DragAnnouncementContext, type DragAnnouncementOptions, type DragAnnouncements, type DragInstructionsProps, type DragLiveRegionProps, type DragStrings, type DropTarget, type KeyboardSensorOptions, type PointerActivation, } from "./lib/dnd";
+export type { MessageRole, MessagePart, MessagePartType, TextPart, CodePart, ReasoningPart, ToolPart, ToolStatus, FilePart, ComponentPart, ChatFile, ChatMessage, RenderContext, PartRenderer, PartRenderers, ChatComponentRenderer, ChatComponents, } from "./components/chat/types";
+export { Chat, ChatPopover, type ChatProps, type ChatPopoverProps, type ChatSurface, } from "./components/chat/Chat";
+export { Message, MessagePartView, ToolCall, ChatMarker, type MessageProps, type MessageAction, type MessagePartViewProps, type ToolCallProps, type ChatMarkerProps, } from "./components/chat/Message";
+export { MessageScroller, type MessageScrollerProps, } from "./components/chat/MessageScroller";
+export { Composer, type ComposerProps } from "./components/chat/Composer";
+export { Markdown, CodeBlock, type MarkdownProps, type CodeBlockProps } from "./components/chat/Markdown";
+export { Attachment, AttachmentList, AttachmentPreview, formatBytes, type AttachmentProps, type AttachmentListProps, type AttachmentPreviewProps, type AttachmentLayout, } from "./components/chat/Attachment";
+export { ModelSelector, type ModelSelectorProps, type ChatModel, } from "./components/chat/ModelSelector";
+export { EffortControl, DEFAULT_EFFORT_LEVELS, type EffortControlProps, type EffortLevel, } from "./components/chat/EffortControl";
+export { ContextMeter, ChatStatus, formatTokens, type ContextMeterProps, type ContextSegment, type UsageLimit, type ChatStatusProps, } from "./components/chat/ContextMeter";
+export { cn } from "./lib/cn";
+export { useTheme, useUiScale, useContrast, useMotionPreference, type Theme, type UiScale, type ContrastPreference, type MotionPreference, } from "./lib/preferences";
+export { usePersistedState, readStored, writeStored, clearStored, storageKey, type PersistedStateOptions, } from "./lib/persist";
+export { CalendarMonth, type CalendarMonthProps } from "./components/calendar/CalendarMonth";
+export { CalendarTimeGrid, type CalendarTimeGridProps, } from "./components/calendar/CalendarTimeGrid";
+export { useNow, type UseNowOptions } from "./components/calendar/use-now";
+export { EventActions, type EventActionsProps } from "./components/calendar/EventActions";
+export { useCalendarDrag, type CalendarDragOptions, type CalendarDragState, } from "./components/calendar/use-calendar-drag";
+export { useEventKeyboard, type EventKeyboardOptions, type EventKeyboardState, } from "./components/calendar/use-event-keyboard";
+export { applyCalendarDelta, calendarDragResult, createdEvent, describeTarget, resolveCalendarTarget, snapInstant, MIN_DURATION_MINUTES, type CalendarDragOrigin, type CalendarDragResult, type CalendarTarget, type ColumnRect, } from "./lib/calendar/drag";
+export { EVENT_PALETTE, DEFAULT_PALETTE_KEY, isPaletteKey, paletteFor, } from "./components/calendar/palette";
+export { cellLabel, eventLabel, formatDateRange, longDate, monthTitle, timeOfDay, weekdayName, zoneLabel, } from "./components/calendar/format";
+export { initialFocusDay, isInMonth, nextDayForKey, useGridNavigation, type GridNavigation, type GridNavigationOptions, } from "./components/calendar/use-grid-navigation";
+export { AmbiguousTimeError, addDays, addDuration, addMonths, atMidnight, atTime, comparePlainDate, dayFraction, dayLengthMs, dayOfWeek, daysBetween, daysInMonth, endOfMonth, hoursInDay, instantAtFraction, instantToPlainDate, instantToPlainDateTime, isSameDate, isoDateString, isoDateTimeString, monthGridDays, nextDay, offsetAt, parsePlainDate, plainDateTimeToInstant, startOfDay, startOfMonth, startOfWeek, weekDays, type CalendarDuration, type Disambiguation, type Instant, type PlainDate, type PlainDateTime, type TimeZone, } from "./lib/time";
+export { allDayBandSegment, dayKey, daySlots, isAllDay, packBand, packLanes, snapFractionToInstant, timeSegments, timedBandSegment, type AllDayEvent, type BandInput, type BandOptions, type BandPlacement, type BandResult, type BandSegment, type CalendarEvent, type CalendarEventId, type CalendarView, type DaySlot, type DragKind, type EventDraft, type EventPalette, type LaneInput, type LaneOptions, type LanePlacement, type PaletteEntry, type TimeSegment, type TimedEvent, type VisibleRange, } from "./lib/calendar";
+export { RBACProvider, useRBAC, AccountMenu, DevToolsPopover, RolePermissionMatrix, ProfilePage, RolesPermissionsPage, type RBACProviderProps, type RBACHookResult, type AccountMenuProps, type DevToolsPopoverProps, type RolePermissionMatrixProps, type Permission, type Role, type User, type Team, type TeamMembership, } from "./components/rbac";
+export { UseCaseCard, RoadmapItemCard, RoadmapSwimlaneBoard, UseCaseLedgerPage, RoadmapPage, PhaseManager, deriveRoadmapItemStatus, toneForIndex, CATEGORY_TONES, type Domain, type Phase, type RoadmapItem, type RoadmapItemStatus, type UseCase, type UseCaseStatus, type UseCaseDecision, type UseCaseCardProps, type RoadmapItemCardProps, type RoadmapSwimlaneBoardProps, type UseCaseLedgerPageProps, type RoadmapPageProps, type PhaseManagerProps, } from "./components/roadmap";
+export { createSimStore, resetSimStores, useSimSettings, setSimSettings, getNetworkSpeed, getDataSource, simulateLatency, SimNetworkError, type SimStore, type SimStoreOptions, type SimSettings, type NetworkSpeed, type DataSource, type SimNamespace, } from "./lib/sim";

package/dist/types/lib/calendar/band-packer.d.ts

@@ -0,0 +1,53 @@
+/** A contiguous run of columns within one row of the grid. Both ends inclusive. */
+export interface BandInput {
+    readonly key: string;
+    readonly startColumn: number;
+    readonly endColumn: number;
+    /**
+     * Ordering weight. Lower sorts earlier, so pinned items keep their place as
+     * neighbours come and go. Ties fall through to span length, then key.
+     */
+    readonly priority?: number;
+}
+export interface BandPlacement extends BandInput {
+    /** 0-based row within the band. */
+    readonly row: number;
+}
+export interface BandResult {
+    /** Everything that fits, in row order. */
+    readonly placed: readonly BandPlacement[];
+    /** Everything pushed past the limit, in the same order it would have had. */
+    readonly hidden: readonly BandInput[];
+    /** Per column, how many hidden items cover it — the "+N more" count. */
+    readonly overflow: readonly number[];
+    /** Rows actually used by `placed`. */
+    readonly rows: number;
+}
+export interface BandOptions {
+    /** How many columns the row has. Required — it sizes the overflow tally. */
+    readonly columns: number;
+    /**
+     * Most rows the band may occupy, INCLUDING the row the "+N more" affordance
+     * takes.
+     *
+     * Counting the affordance is what stops the classic off-by-one where the
+     * overflow link is drawn on top of the last event. When items do not fit,
+     * events get `maxRows - 1` rows and the last is reserved — which is
+     * FullCalendar's `dayMaxEventRows` semantics, and the only version that
+     * leaves room for the thing it just decided to draw.
+     *
+     * Omit for no limit. The all-day band MUST pass one: an uncapped band eats
+     * the container and makes the time grid unreachable — an open FullCalendar
+     * bug, and react-big-calendar's default is literally `Infinity`.
+     */
+    readonly maxRows?: number;
+}
+/**
+ * Assign each item the first row where every column it covers is free.
+ *
+ * Greedy first-fit. Not optimal in the sense of minimising rows — that is
+ * NP-hard and nobody wants it anyway, because the optimal packing reshuffles
+ * every event's row whenever one is added, and a calendar whose events jump
+ * rows as you type is worse than one that uses an extra row.
+ */
+export declare function packBand(inputs: readonly BandInput[], options: BandOptions): BandResult;

package/dist/types/lib/calendar/drag.d.ts

@@ -0,0 +1,125 @@
+import { type Instant, type PlainDate, type TimeZone } from "@/lib/time";
+import type { CalendarDuration } from "@/lib/time";
+import type { DragKind, TimedEvent } from "./types";
+/** A day column, as the view measured it. */
+export interface ColumnRect {
+    readonly day: PlainDate;
+    readonly left: number;
+    readonly right: number;
+    readonly top: number;
+    readonly bottom: number;
+}
+/** Where a pointer is, in calendar terms. */
+export interface CalendarTarget {
+    readonly dayIndex: number;
+    readonly day: PlainDate;
+    /** Snapped to `snapMinutes`, measured from that day's own first instant. */
+    readonly instant: Instant;
+}
+export interface ResolveOptions {
+    readonly zone: TimeZone;
+    readonly columns: readonly ColumnRect[];
+    readonly snapMinutes: number;
+}
+/**
+ * Which day and which time a point is over.
+ *
+ * `null` outside every column — and the caller KEEPS THE LAST NON-NULL TARGET
+ * rather than treating that as "no drop". A pointer leaves the columns
+ * constantly while dragging toward the edge of the grid, and an event that
+ * snapped back to its origin every time the finger crossed the gutter would be
+ * unusable.
+ */
+export declare function resolveCalendarTarget(point: {
+    x: number;
+    y: number;
+}, options: ResolveOptions): CalendarTarget | null;
+/**
+ * Snap an instant to the nearest `snapMinutes`, measured from the DAY'S OWN
+ * first instant.
+ *
+ * Not from midnight and not from the epoch. On a day that begins at 01:00 —
+ * Havana in March — snapping to the epoch puts every slot boundary an hour away
+ * from the rails the grid drew, in exactly the zones where a user is least able
+ * to explain what they are seeing.
+ */
+export declare function snapInstant(zone: TimeZone, day: PlainDate, instant: Instant, snapMinutes: number): Instant;
+export interface CalendarDragOrigin {
+    readonly event: TimedEvent;
+    readonly kind: DragKind;
+    /** The target under the pointer when the gesture activated. */
+    readonly from: CalendarTarget;
+}
+export interface CalendarDragResult {
+    /**
+     * The change, as a CALENDAR duration — never milliseconds.
+     *
+     * "One day later" is 23 hours across a spring-forward boundary and 25 across
+     * a fall-back. A user dragging an event from Saturday to Sunday expects it to
+     * keep its wall-clock time, and a millisecond delta cannot express that. It
+     * is the bug in every library surveyed.
+     */
+    readonly delta: CalendarDuration;
+    /** False when the gesture would leave the event exactly where it was. */
+    readonly moved: boolean;
+    /**
+     * Set when a resize would produce a zero or negative duration.
+     *
+     * REJECTED, NOT CLAMPED. FullCalendar returns no mutation at all;
+     * react-big-calendar clamps, and asymmetrically — its bottom-edge rule can
+     * produce a ZERO-DURATION event, which then renders as an invisible sliver
+     * the user cannot grab to fix. Refusing the gesture leaves the event where it
+     * was, which the user can see and try again from.
+     */
+    readonly invalid?: "too-short";
+}
+/**
+ * The minimum an event may be resized to, in minutes.
+ *
+ * One snap step. Anything smaller cannot be expressed by the gesture that made
+ * it, so it could never be undone by the same gesture.
+ */
+export declare const MIN_DURATION_MINUTES = 15;
+/**
+ * What a gesture from `origin` to `target` means.
+ *
+ * DAYS AND MINUTES SEPARATELY, and that separation is the whole point. The day
+ * component is a CALENDAR move — re-anchored to the same wall-clock time on the
+ * new day. The minute component is EXACT elapsed time — dragging down two hours
+ * means two hours. Both are true at once, and collapsing them into one number
+ * loses whichever property the collapse did not preserve.
+ */
+export declare function calendarDragResult(origin: CalendarDragOrigin, target: CalendarTarget, zone: TimeZone, minDurationMinutes?: number): CalendarDragResult;
+/**
+ * The event as it would be after `delta`, for the live preview.
+ *
+ * COMPOSED ONTO THE EVENT AT CALL TIME, never onto a snapshot taken at
+ * pointer-down. Two real failures from other calendars' trackers: a re-render
+ * replaces the event store mid-drag and the drag is left holding an instance
+ * from the dead one; and a concurrent server update during a drag DUPLICATES
+ * the times, because a snapshot was composited on top of data that had moved
+ * underneath it. Recomputing from whatever the event says now makes a change
+ * arriving mid-gesture compose rather than clobber.
+ */
+export declare function applyCalendarDelta(event: TimedEvent, kind: DragKind, delta: CalendarDuration, zone: TimeZone): TimedEvent;
+/**
+ * The event a drag-to-create gesture would produce.
+ *
+ * The two ends are ordered, so dragging upward creates the same event as
+ * dragging downward across the same span — which is what every calendar does
+ * and what a user expects from a rubber-band gesture.
+ */
+export declare function createdEvent(anchor: CalendarTarget, target: CalendarTarget, minDurationMinutes?: number): {
+    start: Instant;
+    endExclusive: Instant;
+    day: PlainDate;
+};
+/**
+ * A human description of the position, for the live region.
+ *
+ * "Moved to 2:30 PM, Wednesday" — the SLOT, not the fact that something moved.
+ * "Moved" alone tells a screen-reader user nothing they can act on.
+ */
+export declare function describeTarget(target: CalendarTarget, zone: TimeZone, locale?: string): string;
+/** Where in the grid a fraction sits, for the preview. Inverse of the resolve. */
+export declare function fractionOf(zone: TimeZone, day: PlainDate, instant: Instant): number;

package/dist/types/lib/calendar/index.d.ts

@@ -0,0 +1,4 @@
+export { isAllDay, type AllDayEvent, type CalendarEvent, type CalendarEventId, type CalendarView, type DragKind, type EventDraft, type EventPalette, type PaletteEntry, type TimedEvent, type VisibleRange, } from "./types";
+export { packLanes, type LaneInput, type LaneOptions, type LanePlacement } from "./lane-packer";
+export { packBand, type BandInput, type BandOptions, type BandPlacement, type BandResult } from "./band-packer";
+export { allDayBandSegment, dayKey, daySlots, snapFractionToInstant, timeSegments, timedBandSegment, type BandSegment, type DaySlot, type TimeSegment, } from "./segments";

package/dist/types/lib/calendar/lane-packer.d.ts

@@ -0,0 +1,88 @@
+/** A half-open interval `[start, end)` in column fractions, with an identity. */
+export interface LaneInput {
+    readonly key: string;
+    readonly start: number;
+    readonly end: number;
+}
+export interface LanePlacement {
+    readonly key: string;
+    /** As laid out — possibly inflated past the input by `minSpan`. */
+    readonly start: number;
+    readonly end: number;
+    /** 0-based lane within this event's collision batch. */
+    readonly column: number;
+    /** Lanes in that batch. Uniform across every member of it — see below. */
+    readonly lanes: number;
+    /** Fraction of the container's width, from its leading edge. */
+    readonly left: number;
+    readonly width: number;
+    /** Later columns paint over earlier ones. Equal to `column`. */
+    readonly zIndex: number;
+}
+export interface LaneOptions {
+    /**
+     * `cascade` — every event runs to the container's trailing edge and later
+     * columns paint over earlier ones. **This is the Google look and the
+     * default.** `split` — the batch divides the width evenly and nothing
+     * overlaps.
+     *
+     * Three products, three different cascade multipliers: Schedule-X runs to the
+     * edge, FullCalendar doubles the lane width capped at 1, and
+     * react-big-calendar uses 1.7x — arbitrary and unexplained anywhere in its
+     * source. Running to the edge is the only one of the three that is a rule
+     * rather than a number someone liked.
+     */
+    readonly mode?: "cascade" | "split";
+    /**
+     * The smallest span an event may occupy, as a column fraction.
+     *
+     * A 5-minute event on a 12-hour column is 0.7% of it — unclickable, and
+     * unreadable long before that. So it is inflated to a floor.
+     *
+     * **THE INFLATED SPAN IS WHAT COLLISION USES TOO**, which is the part that is
+     * easy to get wrong. Two 5-minute events a minute apart do not overlap as
+     * intervals, but they overlap ON SCREEN once both are inflated to a clickable
+     * height — so laying them in the same lane stacks one on the other. Detecting
+     * collisions on the true interval and drawing the inflated one is how a
+     * calendar ends up with events sitting invisibly behind each other.
+     */
+    readonly minSpan?: number;
+    /**
+     * Cap on lanes per batch. Beyond it, events STACK in the last lane rather
+     * than disappear.
+     *
+     * A week column is around 120px; a fifth lane in it is 24px and unreadable.
+     * But hiding an event in a time grid is worse than overlapping one — the user
+     * can see and click something that overlaps, and cannot do either with
+     * something that is not there. So the cap limits the DIVISION, not the
+     * membership. Day view passes no cap.
+     */
+    readonly maxLanes?: number;
+    /**
+     * Floor on the rendered width, as a fraction.
+     *
+     * Guards the width-0 collapse — an open FullCalendar bug where enough
+     * concurrent events divide the column into nothing and the whole batch
+     * becomes invisible. A floor makes a crowded column ugly instead of empty.
+     */
+    readonly minWidth?: number;
+}
+/**
+ * Lay out overlapping events across lanes.
+ *
+ * Four steps, and the third is the colouring:
+ *
+ *   1. Sort by the total order above.
+ *   2. Sweep into COLLISION BATCHES — a batch closes when the next event starts
+ *      at or after the maximum end of everything accumulated so far. Two events
+ *      in different batches provably cannot overlap, so lane counts never leak
+ *      between them and one crowded hour does not narrow the whole day.
+ *   3. Within a batch, give each event the SMALLEST lane index not taken by an
+ *      earlier member it overlaps. That is greedy colouring of an interval
+ *      graph, and on interval graphs greedy in start order is OPTIMAL — it uses
+ *      exactly the number of lanes the maximum concurrency requires.
+ *   4. `lanes = maxColumn + 1`, computed ONCE PER BATCH and applied uniformly to
+ *      every member. Per-event lane counts are what make two side-by-side
+ *      events different widths for no visible reason.
+ */
+export declare function packLanes(inputs: readonly LaneInput[], options?: LaneOptions): LanePlacement[];

package/dist/types/lib/calendar/segments.d.ts

@@ -0,0 +1,91 @@
+import { isoDateString, type Instant, type PlainDate, type TimeZone } from "@/lib/time";
+import type { AllDayEvent, CalendarEvent, TimedEvent } from "./types";
+/** One day's worth of a timed event, positioned within that day's column. */
+export interface TimeSegment {
+    readonly event: TimedEvent;
+    readonly day: PlainDate;
+    /** Index into the range's `days`, so a view can address a column directly. */
+    readonly dayIndex: number;
+    /** Fraction down the column, 0 at the day's first instant, 1 at the next day's. */
+    readonly top: number;
+    readonly bottom: number;
+    /** False when the event began before this day — draw the top edge as cut. */
+    readonly isStart: boolean;
+    /** False when the event continues past this day. */
+    readonly isEnd: boolean;
+}
+/** A run of whole days, for the month grid or the all-day band. */
+export interface BandSegment {
+    readonly event: CalendarEvent;
+    /** Inclusive column index within the row. */
+    readonly startColumn: number;
+    readonly endColumn: number;
+    readonly isStart: boolean;
+    readonly isEnd: boolean;
+}
+/**
+ * Cut a timed event into one segment per day it touches.
+ *
+ * `days` is a contiguous run — a week, or a single day. Days the event does not
+ * touch produce nothing.
+ */
+export declare function timeSegments(zone: TimeZone, days: readonly PlainDate[], event: TimedEvent): TimeSegment[];
+/**
+ * Where an all-day event sits within a row of days.
+ *
+ * `null` when it does not reach this row at all. Both `endColumn` and the
+ * event's own end are handled here so no caller ever does the ±1: the model is
+ * half-open (`endExclusive` is the first day NOT in the event) and a column
+ * index is inclusive, so the conversion happens once, here.
+ */
+export declare function allDayBandSegment(rowDays: readonly PlainDate[], event: AllDayEvent): BandSegment | null;
+/**
+ * Where a TIMED event sits within a row of days, as whole columns.
+ *
+ * The month grid draws timed events as chips in a day cell, so a timed event
+ * that crosses midnight occupies both cells and needs the same clipping
+ * booleans an all-day bar does.
+ */
+export declare function timedBandSegment(zone: TimeZone, rowDays: readonly PlainDate[], event: TimedEvent): BandSegment | null;
+/** One horizontal rail in the time grid, and the wall time it is labelled by. */
+export interface DaySlot {
+    readonly instant: Instant;
+    /** Position down the column, 0–1. */
+    readonly fraction: number;
+    /** 0–23. On a fall-back day one value appears TWICE — see below. */
+    readonly hour: number;
+    readonly minute: number;
+    /** True for the second of a repeated reading, so a view can mark it. */
+    readonly repeated: boolean;
+}
+/**
+ * The rails for one day, generated by WALKING WALL-CLOCK TIME through the zone.
+ *
+ * NOT by dividing the column into 24. That is the difference between a
+ * fall-back day showing **25 rails with 1 AM twice** — which is what the clock
+ * on the wall actually did — and showing 24 evenly spaced labels that are each
+ * an hour wrong after 02:00.
+ *
+ * Walking forward by real elapsed time and reading the clock at each step is
+ * also what makes the 30-minute zone fall out for free: Lord Howe's short day
+ * produces 23 hourly rails and a half-hour remainder, with no branch.
+ */
+export declare function daySlots(zone: TimeZone, day: PlainDate, slotMinutes?: number): DaySlot[];
+/**
+ * The instant a pointer at `fraction` down `day`'s column is over, snapped.
+ *
+ * SNAP IS A HIT-CHANGE, NOT COORDINATE ROUNDING, and the difference is what the
+ * gesture feels like. Resolving which slot the pointer is IN and only reacting
+ * when that slot changes makes the preview jump discretely between positions,
+ * and **that discreteness IS the feedback** — a preview that tracks the pointer
+ * continuously and rounds on drop reads as mushy and imprecise.
+ *
+ * `snapMinutes` is deliberately independent of the rail spacing. FullCalendar,
+ * react-big-calendar and Schedule-X all couple them; Google and Mobiscroll do
+ * not, and **Google is 15-minute snap on 60-minute rails**, which is the
+ * combination that feels right. Retrofitting the split is a rewrite, so the two
+ * are separate values from the first commit.
+ */
+export declare function snapFractionToInstant(zone: TimeZone, day: PlainDate, fraction: number, snapMinutes: number): Instant;
+/** Stable key for a day, for maps and React keys. */
+export declare const dayKey: typeof isoDateString;

package/dist/types/lib/calendar/types.d.ts

@@ -0,0 +1,166 @@
+import type { CalendarDuration, Instant, PlainDate, TimeZone } from "@/lib/time/types";
+export type CalendarEventId = string;
+interface EventCommon {
+    readonly id: CalendarEventId;
+    readonly title: string;
+    /**
+     * Which series this occurrence belongs to, if any.
+     *
+     * PRESENT FROM THE FIRST COMMIT ALTHOUGH RECURRENCE SHIPS LATER, because
+     * this is the half that cannot be added afterwards. The moment any real data
+     * exists, backfilling series identity onto rows that never had it is a
+     * migration nobody can write correctly — there is no way to tell, later,
+     * which of two identical Tuesday stand-ups belonged to which series.
+     */
+    readonly seriesId?: string;
+    /**
+     * A short human label for the calendar this event came from, rendered ON the
+     * chip.
+     *
+     * NOT decoration, and not satisfied by a legend. Colour-coding is only
+     * conforming when the information it carries is also available another way,
+     * and the remedy has to sit on the coded item itself — a key elsewhere on the
+     * page requires the reader to hold a colour in their head and go looking.
+     */
+    readonly calendarLabel?: string;
+    /** A key into the calendar's palette. Never a raw colour — see `EventPalette`. */
+    readonly paletteKey?: string;
+    /**
+     * Whether this event may be dragged, resized, or otherwise moved.
+     *
+     * Defaults to editable at the calendar level, not here: an undefined value
+     * means "ask the calendar", and only an explicit `false` pins one event down
+     * while its neighbours stay live.
+     */
+    readonly editable?: boolean;
+    /** Anything the consumer wants back in a render prop or an event handler. */
+    readonly data?: unknown;
+}
+/**
+ * An event with a time of day, anchored to a real instant.
+ *
+ * Both ends are `Instant`s, so the event means the same moment regardless of
+ * which zone renders it. A meeting at 09:00 in New York is at 14:00 in London
+ * and both are the same event; storing wall-clock fields instead makes it two
+ * different events that happen to be spelled alike.
+ */
+export interface TimedEvent extends EventCommon {
+    readonly allDay: false;
+    readonly start: Instant;
+    /**
+     * The first instant NOT in the event. Half-open: `start <= t < endExclusive`.
+     *
+     * THE NAME IS THE DOCUMENTATION, deliberately. Half-open intervals make
+     * `duration = end - start` correct, make adjacent events provably
+     * non-overlapping, and make every algorithm in the layout core fall out
+     * without a `+1` anywhere — overlap is `aStart < bEnd && bStart < aEnd`, with
+     * no special case for two events that merely touch.
+     *
+     * The cost is the most-reported bug in calendar interoperability: a
+     * one-day event stored as 23rd → 24th renders as two days in any consumer
+     * that reads the end as inclusive. So the ±1 conversion happens in exactly
+     * TWO places — the display formatter and the date-picker binding — and the
+     * field is named so that nobody has to remember which convention this is.
+     */
+    readonly endExclusive: Instant;
+    /**
+     * The start this occurrence had when the series first produced it.
+     *
+     * THE PERMANENT JOIN KEY FOR AN OVERRIDE, and the single most common
+     * recurrence-model mistake is keying by the CURRENT start instead. Do that
+     * and the override becomes unjoinable the moment somebody drags the event:
+     * the series still generates an occurrence at the original time, the
+     * override now claims a different one, and the calendar shows both.
+     *
+     * Set once, never updated. Absent on an event that is not part of a series.
+     */
+    readonly originalStart?: Instant;
+}
+/**
+ * An event that occupies whole days.
+ *
+ * IT CARRIES NO ZONE, AND THAT IS THE POINT. A birthday is on the 4th of March
+ * everywhere; model it as an instant and it moves to the 3rd for anyone far
+ * enough west. `PlainDate` has no offset to be wrong about.
+ */
+export interface AllDayEvent extends EventCommon {
+    readonly allDay: true;
+    readonly start: PlainDate;
+    /** The first day NOT in the event — same half-open rule as `TimedEvent`. */
+    readonly endExclusive: PlainDate;
+    /** See `TimedEvent.originalStart`. A date, because an all-day event has no time. */
+    readonly originalStart?: PlainDate;
+}
+export type CalendarEvent = TimedEvent | AllDayEvent;
+/** Narrowing helper, so consumers never test `allDay` by hand. */
+export declare function isAllDay(event: CalendarEvent): event is AllDayEvent;
+/** Which part of an event a gesture is moving. */
+export type DragKind = "move" | "resize-start" | "resize-end" | "create";
+/**
+ * A gesture in progress, as a DELTA against the committed event.
+ *
+ * NEVER A REWRITTEN COPY OF THE EVENT, and never a reference to one. Two real
+ * failures from other calendars' trackers, both of which this shape makes
+ * impossible:
+ *
+ *   A re-render replaces the event store mid-drag, and the drag is left holding
+ *   an instance from the store that no longer exists — so the drop writes stale
+ *   values over fresh ones.
+ *
+ *   A concurrent update arrives from a server during a drag and the times end
+ *   up DUPLICATED, because a snapshot taken at pointer-down was composited on
+ *   top of data that had moved underneath it.
+ *
+ * A delta keyed by id composes instead of clobbering: whatever the event says
+ * at the moment of the drop, the gesture's meaning is "two hours later than
+ * that", and a change arriving underneath is respected rather than overwritten.
+ *
+ * `delta` IS A CALENDAR DURATION, not a number of milliseconds — see
+ * `CalendarDuration`. Dragging across a spring-forward boundary must preserve
+ * the wall-clock time, and a millisecond delta cannot express that.
+ */
+export interface EventDraft {
+    readonly id: CalendarEventId;
+    readonly kind: DragKind;
+    readonly delta: CalendarDuration;
+}
+/**
+ * One swatch, with its text colour ALREADY PAIRED and verified.
+ *
+ * WHY NOT COMPUTE THE TEXT COLOUR. The familiar trick — measure the fill's
+ * luminance and flip to black or white — fails in a band in the middle where
+ * NEITHER clears AA against the fill. The threshold is also not 0.5: it is
+ * around 0.38, and implementations that use 0.5 pick white on colours that
+ * needed black. Google ships two entire palettes ("white text" and "black
+ * text") rather than compute a flip, which is the same conclusion arrived at
+ * from the other direction.
+ *
+ * So the palette is curated, each pair is measured, and a consumer supplying
+ * arbitrary hex gets a documented refusal rather than an unreadable chip.
+ */
+export interface PaletteEntry {
+    readonly key: string;
+    /** Human name, used in the accessible label so colour is never the only cue. */
+    readonly label: string;
+    readonly fill: string;
+    readonly text: string;
+    /** Border and left-edge accent; darker than `fill`, still AA against it. */
+    readonly edge: string;
+}
+export type EventPalette = readonly PaletteEntry[];
+export type CalendarView = "day" | "week" | "month";
+/**
+ * The days a view is currently showing, and the zone it is showing them in.
+ *
+ * `days` is EXPLICIT rather than a start/end pair, because a month grid's days
+ * are not a contiguous range in any useful sense — they cross two month
+ * boundaries and the layout core needs to address them positionally.
+ */
+export interface VisibleRange {
+    readonly view: CalendarView;
+    readonly zone: TimeZone;
+    readonly days: readonly PlainDate[];
+    /** 0 = Sunday. Carried on the range so the packers never have to guess. */
+    readonly weekStartsOn: number;
+}
+export {};

package/dist/types/lib/cn.d.ts

@@ -0,0 +1,7 @@
+import { type ClassValue } from "clsx";
+/**
+ * Merge conditional class names, resolving Tailwind conflicts last-wins.
+ * Every component funnels its class composition through this so a consumer's
+ * `className` always beats the component's own defaults.
+ */
+export declare function cn(...inputs: ClassValue[]): string;