@danxbot/ui 1.0.0

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

@@ -0,0 +1,119 @@
+/**
+ * The token contract. Every grammar in this system produces this shape and
+ * nothing else — the highlighter, the editor overlay, the markdown renderer and
+ * the tests all read it.
+ *
+ * WHY A FLAT TOKEN LIST AND NOT AN HTML STRING. The obvious design (and the one
+ * the Vue original uses) is `highlight(code) -> "<span class=…>…"`, one function
+ * per language. It cannot do the two things this component exists to do:
+ *
+ *   1. EDITING. The editor is a transparent `<textarea>` sitting exactly on top
+ *      of a `<pre>` of the same text. That only works if the rendered text is
+ *      character-for-character the source — same characters, same order, same
+ *      length. A list of offsets into the original string makes that checkable;
+ *      a string of markup makes it a promise nobody can verify.
+ *   2. NESTING. A fenced code block inside markdown, or `<style>` inside a Vue
+ *      SFC, is a region of one language inside another. With offsets, an inner
+ *      grammar's tokens splice into the outer stream and everything downstream
+ *      is unaware anything happened. With strings you are concatenating markup
+ *      and hoping the escaping survives.
+ *
+ * The invariant that makes both work, asserted by `tokenize`'s own tests:
+ * tokens are non-overlapping, ascending, and cover the whole input with no
+ * gaps. `src.slice(t.start, t.end)` joined over every token IS the source.
+ */
+/**
+ * Token categories. Deliberately a closed set: each one maps to exactly one CSS
+ * custom property in `src/styles/syntax.css`, so a language cannot invent a
+ * colour, and adding a category is a visible, one-place decision.
+ *
+ * Named for ROLE rather than for any one language's grammar — `property` covers
+ * a JSON key, a CSS declaration name and a JS object key, because all three are
+ * "the name on the left" and should read the same way in every language.
+ */
+export type TokenType = "text" | "comment" | "punctuation" | "operator" | "string" | "escape" | "number" | "boolean" | "null" | "regex" | "keyword" | "property" | "variable" | "function" | "type" | "constant" | "tag" | "attribute" | "selector" | "atrule" | "heading" | "emphasis" | "strong" | "strike" | "link" | "url" | "marker" | "quote" | "invalid";
+/** A run of source text with one category. Half-open range: `[start, end)`. */
+export interface Token {
+    /** Offset into the ORIGINAL source string, never into a nested substring. */
+    start: number;
+    end: number;
+    type: TokenType;
+    /**
+     * The grammar that produced this token. An embedded region carries the INNER
+     * language's name, which is what lets a consumer style a fenced block
+     * differently from the markdown around it — and what makes a nesting bug
+     * visible in a test rather than merely wrong on screen.
+     */
+    lang: string;
+}
+/**
+ * One scanning rule, tried in order at the current position.
+ *
+ * `match` MUST carry the sticky flag. A non-sticky regex searches forward from
+ * the position and can match text the scanner has not reached, silently
+ * swallowing the characters in between — the failure looks like "highlighting
+ * is slightly off" and is very hard to trace back. `defineGrammar` throws on a
+ * non-sticky pattern rather than letting that ship.
+ */
+export interface Rule {
+    match: RegExp;
+    /** Category for the entire match. Mutually exclusive with `groups`. */
+    token?: TokenType;
+    /**
+     * Category per capture group, for a rule that matches several things at once
+     * (`key` `:` in JSON, `<` `div` in HTML). `null` leaves a group as plain
+     * text. Anything between groups is emitted as `text`, so coverage holds.
+     */
+    groups?: (TokenType | null)[];
+    /** Enter another state of the SAME grammar (a string body, a comment). */
+    push?: string;
+    /** Leave the current state. Applied after the token is emitted. */
+    pop?: true;
+    /**
+     * Enter ANOTHER grammar for the region that follows, until `until` matches.
+     * A string names it outright (`<style>` -> css); a function reads it off the
+     * match, which is how a fence takes its language from its own info string and
+     * how `<script lang="ts">` differs from `<script>`.
+     *
+     * Returning null (unknown language) is not an error — the region is scanned
+     * as plain text and still terminates correctly at `until`. An unrecognised
+     * language must never break the document containing it.
+     */
+    embed?: string | ((match: RegExpExecArray) => string | null);
+    /** Required with `embed`: the pattern that ends the embedded region. */
+    until?: RegExp;
+    /** Category for the terminator itself. Defaults to `punctuation`. */
+    untilToken?: TokenType;
+}
+/**
+ * A language. `states.root` is the entry point; other states are pushed by
+ * rules. Most grammars need only `root` plus a state per multi-line construct.
+ */
+export interface Grammar {
+    name: string;
+    aliases?: readonly string[];
+    states: Record<string, Rule[]>;
+    /**
+     * Full override for a language the rule stack genuinely cannot express.
+     * Markdown is the only one: its structure is by BLOCK (a list item's content
+     * is decided by indentation relative to its marker, several lines later),
+     * which no positional rule stack can see. It parses properly and emits this
+     * same token shape, so every consumer stays unaware of the difference.
+     *
+     * A grammar with `tokenize` may leave `states` empty.
+     */
+    tokenize?: (source: string, ctx: TokenizeContext) => Token[];
+}
+/**
+ * Handed to a `tokenize` override so it can highlight regions of other
+ * languages — a fenced block, YAML front matter — without importing the
+ * registry itself and creating a cycle.
+ */
+export interface TokenizeContext {
+    /**
+     * Tokenize `source` as `language`, with every offset shifted by `offset` so
+     * the result splices into the caller's stream. An unknown language yields one
+     * `text` token, never an error.
+     */
+    sub(source: string, language: string | null, offset: number): Token[];
+}

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

@@ -0,0 +1,3 @@
+export { AmbiguousTimeError, isoDateString, isoDateTimeString, type CalendarDuration, type Disambiguation, type Instant, type PlainDate, type PlainDateTime, type TimeZone, } from "./types";
+export { addDuration, dayFraction, dayLengthMs, hoursInDay, instantAtFraction, instantToPlainDate, instantToPlainDateTime, nextDay, offsetAt, plainDateTimeToInstant, startOfDay, } from "./zone";
+export { addDays, addMonths, atMidnight, atTime, comparePlainDate, dayOfWeek, daysBetween, daysInMonth, endOfMonth, isSameDate, monthGridDays, parsePlainDate, startOfMonth, startOfWeek, weekDays, } from "./plain";

package/dist/types/lib/time/plain.d.ts

@@ -0,0 +1,61 @@
+import { isoDateString, type PlainDate, type PlainDateTime } from "./types";
+/** Days in `month` of `year`, leap years included. */
+export declare function daysInMonth(year: number, month: number): number;
+/** `date` moved by `days`, which may be negative, rolling months and years. */
+export declare function addDays(date: PlainDate, days: number): PlainDate;
+/**
+ * `date` moved by `months`, clamping the day to the target month's length.
+ *
+ * CLAMPING, NOT ROLLING: one month after the 31st of January is the 28th or
+ * 29th of February, never the 3rd of March. Rolling is what `Date.setMonth`
+ * does natively and it is why "next month" buttons skip February.
+ */
+export declare function addMonths(date: PlainDate, months: number): PlainDate;
+/** Whole days from `a` to `b`; negative when `b` is earlier. */
+export declare function daysBetween(a: PlainDate, b: PlainDate): number;
+/** Negative when `a` is earlier, 0 when equal, positive when later. */
+export declare function comparePlainDate(a: PlainDate, b: PlainDate): number;
+export declare function isSameDate(a: PlainDate, b: PlainDate): boolean;
+/** 0 = Sunday … 6 = Saturday, matching `Date.getUTCDay` and `Intl`'s weekday order. */
+export declare function dayOfWeek(date: PlainDate): number;
+/**
+ * The first day of the week `date` falls in.
+ *
+ * `weekStartsOn` IS A PARAMETER WITH NO DEFAULT ANYWHERE UP THE STACK, because
+ * there is no correct global answer: Sunday in the US and Japan, Monday across
+ * Europe and by ISO 8601, Saturday in much of the Middle East. A component that
+ * picks one silently is wrong for most of the world, so the calendar surfaces
+ * it and this function simply obeys.
+ */
+export declare function startOfWeek(date: PlainDate, weekStartsOn: number): PlainDate;
+/** The 1st of `date`'s month. */
+export declare function startOfMonth(date: PlainDate): PlainDate;
+/** The last day of `date`'s month. */
+export declare function endOfMonth(date: PlainDate): PlainDate;
+/**
+ * Every day a month grid shows, INCLUDING the leading and trailing days that
+ * belong to the neighbouring months.
+ *
+ * Always whole weeks, so the result is a multiple of seven and the grid never
+ * has a ragged edge. The count varies — a 28-day February beginning on the
+ * week's first day needs four rows, and a 31-day month beginning on its last
+ * day needs six. Callers that assume six rows draw an empty one eleven months
+ * a year; callers that assume five are simply wrong twice a year.
+ */
+export declare function monthGridDays(date: PlainDate, weekStartsOn: number): PlainDate[];
+/** The seven days of the week `date` falls in. */
+export declare function weekDays(date: PlainDate, weekStartsOn: number): PlainDate[];
+/**
+ * Parse `YYYY-MM-DD`.
+ *
+ * FAILS LOUDLY on anything else, including the shapes `Date` accepts and
+ * silently reinterprets. `new Date("2026-2-30")` yields the 2nd of March, which
+ * is a data error becoming a rendered event on the wrong day with nothing
+ * anywhere reporting a problem.
+ */
+export declare function parsePlainDate(iso: string): PlainDate;
+export { isoDateString };
+/** A `PlainDateTime` at midnight on `date` — the wall reading, not an instant. */
+export declare function atMidnight(date: PlainDate): PlainDateTime;
+/** A `PlainDateTime` at `hour`:`minute` on `date`. */
+export declare function atTime(date: PlainDate, hour: number, minute?: number): PlainDateTime;

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

@@ -0,0 +1,87 @@
+/**
+ * A point on the timeline, as milliseconds since the epoch.
+ *
+ * NOT a `Date`. A `Date` is a mutable object that prints itself in the host's
+ * local zone, and every calendar bug in the survey behind this component
+ * involved someone reading a `Date`'s local fields when they meant a specific
+ * zone's. A number cannot be misread that way — it has no fields to read.
+ */
+export type Instant = number;
+/** An IANA time zone identifier, e.g. `"America/New_York"`. */
+export type TimeZone = string;
+/**
+ * A calendar day. No time, no zone, no offset — just which square on the wall.
+ *
+ * `month` IS ONE-BASED, matching `Temporal` and matching how every human writes
+ * a date. `Date`'s zero-based month is the single most common off-by-one in
+ * date code and it is not reproduced here.
+ */
+export interface PlainDate {
+    readonly year: number;
+    /** 1–12. */
+    readonly month: number;
+    /** 1–31. */
+    readonly day: number;
+}
+/**
+ * A wall-clock reading. What a clock on the wall says, with no claim about
+ * which wall.
+ *
+ * This is the type that makes the ambiguity explicit rather than accidental:
+ * `2026-11-01T01:30` in New York happened TWICE, and `2026-03-08T02:30` never
+ * happened at all. A `PlainDateTime` can represent both, which is precisely why
+ * turning one into an `Instant` requires saying what to do about it.
+ */
+export interface PlainDateTime extends PlainDate {
+    /** 0–23. */
+    readonly hour: number;
+    /** 0–59. */
+    readonly minute: number;
+    /** 0–59. */
+    readonly second: number;
+    /** 0–999. */
+    readonly millisecond: number;
+}
+/**
+ * How much to move, in CALENDAR units rather than elapsed time.
+ *
+ * THE DISTINCTION IS THE WHOLE POINT, and getting it wrong is the bug in every
+ * library surveyed. "One day later" is not "86,400,000 ms later": across a
+ * spring-forward boundary it is 23 hours, and across a fall-back it is 25. A
+ * user dragging an event from Saturday to Sunday expects it to keep its
+ * wall-clock time, so the move has to be expressed as `{ days: 1 }` and
+ * resolved against the zone — never added as a number.
+ *
+ * `hours` and `minutes` ARE exact elapsed time, and that is correct: dragging
+ * an event down by two hours means two hours of real duration.
+ */
+export interface CalendarDuration {
+    readonly days?: number;
+    readonly hours?: number;
+    readonly minutes?: number;
+}
+/**
+ * What to do when a wall-clock reading does not name exactly one instant.
+ *
+ * Spelled as `Temporal.ZonedDateTime.from`'s option of the same name, with the
+ * same meanings, so this is one more thing that becomes a deletion later.
+ *
+ * - `compatible` — what every other date library does, and the default.
+ *   In a GAP (spring forward) move forward by the size of the gap; in an
+ *   OVERLAP (fall back) take the first of the two.
+ * - `earlier` / `later` — take that side explicitly.
+ * - `reject` — throw. For a parser or an import, where a time that never
+ *   existed is a fact about bad input rather than something to paper over.
+ */
+export type Disambiguation = "compatible" | "earlier" | "later" | "reject";
+/** Thrown by `reject` disambiguation, and never by anything else. */
+export declare class AmbiguousTimeError extends Error {
+    readonly wall: PlainDateTime;
+    readonly zone: TimeZone;
+    readonly kind: "gap" | "overlap";
+    constructor(wall: PlainDateTime, zone: TimeZone, kind: "gap" | "overlap");
+}
+/** `2026-03-08T02:30:00.000` — used in errors, and by the ISO helpers. */
+export declare function isoDateTimeString(wall: PlainDateTime): string;
+/** `2026-03-08`. */
+export declare function isoDateString(date: PlainDate): string;

package/dist/types/lib/time/zone.d.ts

@@ -0,0 +1,97 @@
+import { type Disambiguation, type Instant, type PlainDate, type PlainDateTime, type TimeZone } from "./types";
+/** The wall-clock reading in `zone` at `instant`. */
+export declare function instantToPlainDateTime(zone: TimeZone, instant: Instant): PlainDateTime;
+/**
+ * `zone`'s offset from UTC at `instant`, in milliseconds. East is positive.
+ *
+ * THE ONE PRIMITIVE. Read by asking the browser what the wall clock says at
+ * that instant and subtracting: if it is 07:00 UTC and the clock in New York
+ * reads 02:00, the offset is −5 hours. No table, no parsing of a zone name, no
+ * assumption that an offset is a whole number of hours — `Pacific/Chatham` sits
+ * at +12:45, and `Asia/Kathmandu` at +5:45.
+ */
+export declare function offsetAt(zone: TimeZone, instant: Instant): number;
+/**
+ * The instant at which `zone`'s clock reads `wall`.
+ *
+ * See `Disambiguation` for what happens when that is not exactly one instant.
+ * The default is `compatible`, which is what `Temporal` and every other date
+ * library do, so the surprising cases are the ones you have to ask for.
+ */
+export declare function plainDateTimeToInstant(zone: TimeZone, wall: PlainDateTime, disambiguation?: Disambiguation): Instant;
+/** The calendar day `instant` falls on, in `zone`. */
+export declare function instantToPlainDate(zone: TimeZone, instant: Instant): PlainDate;
+/**
+ * The first instant of `date` in `zone`.
+ *
+ * NOT "midnight". In `America/Santiago` on 2026-09-06 the clock jumps from
+ * 00:00 to 01:00, so the day's first instant reads 01:00 — and a grid that
+ * assumes its own origin is midnight puts every event on that day an hour out.
+ * `America/Havana` and `Asia/Beirut` do the same thing on their own dates.
+ *
+ * Implemented by asking for midnight and, when the clock skipped it, walking
+ * forward a minute at a time until a reading exists. The walk is bounded: no
+ * transition in the IANA database exceeds two hours, so 180 iterations cannot
+ * be reached by real data, and the bound exists to fail loudly rather than spin
+ * if that ever stops being true.
+ */
+export declare function startOfDay(zone: TimeZone, date: PlainDate): Instant;
+/** The day after `date` on the calendar, ignoring zones entirely. */
+export declare function nextDay(date: PlainDate): PlainDate;
+/**
+ * How long `date` actually lasts in `zone`, in milliseconds.
+ *
+ * Measured as the distance between one day's first instant and the next day's,
+ * which is true by construction for every case — 23 hours, 25 hours, the 30
+ * minutes of Lord Howe, and a day that starts at 01:00 — with no special case
+ * for any of them. That is the entire reason positions in the grid are a RATIO
+ * of this number rather than `hour × rowHeight`.
+ */
+export declare function dayLengthMs(zone: TimeZone, date: PlainDate): number;
+/**
+ * How many hours `date` lasts in `zone` — 23, 24, 25, or 23.5.
+ *
+ * Fractional by design. `Australia/Lord_Howe` shifts by thirty minutes, so a
+ * signature returning an integer would be lying about a real zone, and any
+ * caller branching on `=== 23` is already broken.
+ */
+export declare function hoursInDay(zone: TimeZone, date: PlainDate): number;
+/**
+ * Where `instant` sits within `date`, as a fraction from 0 to 1.
+ *
+ * THE LOAD-BEARING FUNCTION. A 23-hour day compresses and a 25-hour day
+ * stretches with no branch anywhere, because the divisor is the day's real
+ * length. Values outside 0–1 mean the instant is not on this day and are
+ * returned rather than clamped — the layout core needs to know by how much in
+ * order to clip a multi-day span.
+ */
+export declare function dayFraction(zone: TimeZone, date: PlainDate, instant: Instant): number;
+/**
+ * The exact inverse of `dayFraction`.
+ *
+ * IT MUST BE EXACT, and that is not a stylistic preference. Rendering maps an
+ * instant to a position and hit-testing maps a position back to an instant; if
+ * the two disagree by even a rounding step, an event lands one slot away from
+ * where it was dropped. FullCalendar's Australia selection bug is exactly this
+ * pair drifting apart. `dayFraction(z, d, instantAtFraction(z, d, f)) === f`
+ * for every zone in the corpus, and there is a test that says so.
+ */
+export declare function instantAtFraction(zone: TimeZone, date: PlainDate, fraction: number): Instant;
+/**
+ * Move `instant` by a CALENDAR duration.
+ *
+ * Days are applied on the calendar and then re-anchored to the same wall-clock
+ * time, so an event dragged from Saturday to Sunday across a transition keeps
+ * reading 09:00 rather than becoming 08:00 or 10:00. Hours and minutes are
+ * applied afterwards as exact elapsed time, because dragging an event down the
+ * grid by two hours does mean two hours.
+ *
+ * ORDER MATTERS AND IS FIXED: days first, then time. The other order makes
+ * "one day and two hours later" depend on which side of a transition the
+ * intermediate value happened to land on.
+ */
+export declare function addDuration(zone: TimeZone, instant: Instant, duration: {
+    days?: number;
+    hours?: number;
+    minutes?: number;
+}, disambiguation?: Disambiguation): Instant;

package/dist/types/lib/use-media-query.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Subscribes to a CSS media query and re-renders when it changes.
+ *
+ * WHY A HOOK AND NOT A CSS CLASS. Almost everything responsive in this system
+ * belongs in CSS, where it costs nothing and works before hydration. This
+ * exists for the case CSS cannot reach: a layout whose measurements are written
+ * as INLINE STYLE from application state — a resizable panel group being the
+ * one that matters here. A utility class cannot override `style="flex-grow:3"`,
+ * so the component has to know the width to write a different value.
+ *
+ * Reach for a `lg:` variant first. This is the exception, not the pattern.
+ *
+ * `useSyncExternalStore` rather than `useState` + `useEffect`: it reads the
+ * value during render on the client and returns the server snapshot during SSR,
+ * so there is no first paint at the wrong breakpoint and no hydration mismatch
+ * warning. The effect version renders once with a guess and then corrects
+ * itself, which is a visible layout jump on exactly the devices this is for.
+ */
+export declare function useMediaQuery(query: string, serverFallback?: boolean): boolean;
+/** Tailwind's own breakpoints, so a JS check and a `lg:` class agree. */
+export declare const BREAKPOINTS: {
+    readonly sm: 640;
+    readonly md: 768;
+    readonly lg: 1024;
+    readonly xl: 1280;
+};
+export type Breakpoint = keyof typeof BREAKPOINTS;
+/** True below the named breakpoint — the JS twin of `max-<bp>:`. */
+export declare function useBelow(breakpoint: Breakpoint, serverFallback?: boolean): boolean;

package/package.json

@@ -0,0 +1,130 @@
+{
+  "name": "@danxbot/ui",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Danxbot — a domain-agnostic React design system with motion as a first-class primitive.",
+  "license": "MIT",
+  "author": "Dan Newman",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/newms87/danxbot.git",
+    "directory": "design-system"
+  },
+  "bugs": "https://github.com/newms87/danxbot/issues",
+  "keywords": [
+    "react",
+    "design-system",
+    "component-library",
+    "tailwindcss",
+    "accessible",
+    "animation",
+    "ui"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/types/index.d.ts",
+  "sideEffects": [
+    "*.css"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./styles.css": "./dist/styles.css",
+    "./fonts.css": "./dist/fonts.css",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "gen:api": "node scripts/gen-api-manifest.mjs",
+    "predev": "npm run gen:api",
+    "pretypecheck": "npm run gen:api",
+    "pretest": "npm run gen:api",
+    "prebuild:demo": "npm run gen:api",
+    "dev": "vite",
+    "typecheck": "tsc --noEmit",
+    "typecheck:previews": "tsc -p tsconfig.previews.json",
+    "audit:previews": "node scripts/audit-preview-classes.mjs",
+    "audit:cards": "node scripts/audit-card-theme.mjs",
+    "audit:hover": "node scripts/audit-hover.mjs",
+    "test": "vitest run",
+    "build:lib": "vite build --config vite.lib.config.ts && node scripts/postbuild-css.mjs && npm run build:types",
+    "fonts": "node scripts/fetch-fonts.mjs",
+    "icons": "node scripts/build-icons.mjs",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build:demo": "vite build",
+    "build": "npm run build:lib && npm run build:demo",
+    "verify": "npm run typecheck && npm run test && npm run build && npm run typecheck:previews",
+    "preview": "vite preview",
+    "preview:built": "vite preview --outDir demo-dist --port 5801 --strictPort",
+    "gates": "npm run shoot && npm run a11y && node scripts/shoot-overlays.mjs && npm run probe",
+    "a11y": "node scripts/a11y-scan.mjs",
+    "shoot": "node scripts/shoot.mjs",
+    "probe": "node scripts/probe-scale.mjs && node scripts/probe-switch.mjs && node scripts/probe-panel.mjs && node scripts/probe-popover-width.mjs && node scripts/probe-api.mjs && node scripts/probe-api-live.mjs",
+    "sync": "node scripts/sync.mjs",
+    "visual": "node scripts/visual-docker.mjs",
+    "visual:update": "node scripts/visual-docker.mjs --update-snapshots",
+    "visual:host": "playwright test",
+    "visual:report": "playwright show-report",
+    "audit:arrows": "node scripts/audit-arrows.mjs",
+    "audit:motion": "node scripts/audit-motion.mjs",
+    "audit:responsive": "node scripts/audit-responsive.mjs",
+    "audit:dnd": "node scripts/audit-dnd.mjs && node scripts/probe-dnd-sensors.mjs && node scripts/probe-dnd-a11y.mjs",
+    "audit:axtree": "node scripts/audit-axtree.mjs",
+    "audit:mutations": "node scripts/audit-mutations.mjs",
+    "audit:palette": "node scripts/audit-palette.mjs",
+    "probe:calendar": "node scripts/probe-calendar.mjs",
+    "audit": "npm run audit:previews && npm run audit:cards && npm run audit:arrows && npm run audit:axtree && npm run audit:palette && npm run audit:motion && npm run audit:responsive && npm run audit:hover && npm run a11y && npm run probe:calendar && npm run probe:calendar-drag && npm run audit:dnd && npm run probe:markdown",
+    "probe:calendar-drag": "node scripts/probe-calendar-drag.mjs",
+    "audit:conventions": "node scripts/audit-conventions.mjs",
+    "audit:component-exports": "node scripts/audit-component-exports.mjs",
+    "probe:markdown": "node scripts/probe-markdown-caret.mjs && node scripts/probe-markdown-component.mjs && node scripts/probe-markdown-affordances.mjs",
+    "release": "node --no-deprecation scripts/publish.mjs"
+  },
+  "peerDependencies": {
+    "react": "^19",
+    "react-dom": "^19"
+  },
+  "dependencies": {
+    "@base-ui/react": "^1.7.0",
+    "@tanstack/react-table": "^8.21.3",
+    "clsx": "^2.1.1",
+    "tailwind-merge": "^3.3.1",
+    "tailwind-variants": "^3.3.1"
+  },
+  "devDependencies": {
+    "@axe-core/playwright": "^4.13.0",
+    "@playwright/test": "^1.62.1",
+    "@tailwindcss/vite": "^4.1.14",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^26.2.0",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.1",
+    "@vitejs/plugin-react": "^5.0.4",
+    "axe-core": "^4.13.0",
+    "fumadocs-core": "^16.14.5",
+    "fumadocs-mdx": "^15.3.0",
+    "happy-dom": "^20.11.2",
+    "lucide-react": "^0.545.0",
+    "playwright": "^1.62.1",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "tailwindcss": "^4.1.14",
+    "typescript": "^5.9.3",
+    "vite": "^7.1.9",
+    "vitest": "^4.1.11",
+    "zod": "^4.4.3"
+  },
+  "allowScripts": {
+    "esbuild@0.28.2": true
+  }
+}