@multicomma/arkcn 0.1.0 → 0.1.2

package/registry/items/{use-mobile.json → hooks/use-mobile.json}

@@ -1,7 +1,10 @@
 {
-  "name": "use-mobile",
+  "name": "hooks/use-mobile",
   "type": "hook",
   "description": "",
+  "exports": [
+    "useIsMobile"
+  ],
   "dependencies": {},
   "registryDependencies": [],
   "files": [

package/registry/items/hotkeys.json

@@ -2,11 +2,21 @@
   "name": "hotkeys",
   "type": "ui",
   "description": "-------------------------------- parsing --------------------------------",
+  "exports": [
+    "HotkeyKbd",
+    "HotkeysDialog",
+    "HotkeysProvider",
+    "formatHotkey",
+    "parseHotkey",
+    "useHotkey",
+    "useHotkeys",
+    "useHotkeysDialog"
+  ],
   "dependencies": {},
   "registryDependencies": [
     "dialog",
     "kbd",
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/hover-card.json

@@ -2,11 +2,21 @@
   "name": "hover-card",
   "type": "ui",
   "description": "",
+  "ark": "HoverCard",
+  "exports": [
+    "HoverCard",
+    "HoverCardArrow",
+    "HoverCardContent",
+    "HoverCardContext",
+    "HoverCardPortal",
+    "HoverCardPositioner",
+    "HoverCardTrigger"
+  ],
   "dependencies": {
     "@ark-ui/react": "^5.39.1"
   },
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/image-cropper.json

@@ -2,11 +2,21 @@
   "name": "image-cropper",
   "type": "ui",
   "description": "",
+  "ark": "ImageCropper",
+  "exports": [
+    "ImageCropper",
+    "ImageCropperContext",
+    "ImageCropperGrid",
+    "ImageCropperHandle",
+    "ImageCropperImage",
+    "ImageCropperSelection",
+    "ImageCropperViewport"
+  ],
   "dependencies": {
     "@ark-ui/react": "^5.39.1"
   },
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/input-group.json

@@ -2,14 +2,22 @@
   "name": "input-group",
   "type": "ui",
   "description": "",
+  "exports": [
+    "InputGroup",
+    "InputGroupAddon",
+    "InputGroupTrigger",
+    "InputGroupText",
+    "InputGroupInput",
+    "InputGroupTextarea"
+  ],
   "dependencies": {
     "class-variance-authority": "^0.7.1"
   },
   "registryDependencies": [
     "button",
     "input",
-    "textarea",
-    "utils"
+    "lib/utils",
+    "textarea"
   ],
   "files": [
     {

package/registry/items/input-otp.json

@@ -2,12 +2,18 @@
   "name": "input-otp",
   "type": "ui",
   "description": "",
+  "exports": [
+    "InputOTP",
+    "InputOTPGroup",
+    "InputOTPSlot",
+    "InputOTPSeparator"
+  ],
   "dependencies": {
     "input-otp": "^1.5.0",
     "lucide-react": "^1.41.0"
   },
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/input.json

@@ -2,9 +2,12 @@
   "name": "input",
   "type": "ui",
   "description": "",
+  "exports": [
+    "Input"
+  ],
   "dependencies": {},
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/item.json

@@ -2,13 +2,25 @@
   "name": "item",
   "type": "ui",
   "description": "",
+  "exports": [
+    "Item",
+    "ItemMedia",
+    "ItemContent",
+    "ItemActions",
+    "ItemGroup",
+    "ItemSeparator",
+    "ItemTitle",
+    "ItemDescription",
+    "ItemHeader",
+    "ItemFooter"
+  ],
   "dependencies": {
     "@ark-ui/react": "^5.39.1",
     "class-variance-authority": "^0.7.1"
   },
   "registryDependencies": [
-    "separator",
-    "utils"
+    "lib/utils",
+    "separator"
   ],
   "files": [
     {

package/registry/items/json-tree-view.json

@@ -2,11 +2,16 @@
   "name": "json-tree-view",
   "type": "ui",
   "description": "",
+  "ark": "JsonTreeView",
+  "exports": [
+    "JsonTreeView",
+    "JsonTreeViewTree"
+  ],
   "dependencies": {
     "@ark-ui/react": "^5.39.1"
   },
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/kanban.json

@@ -2,6 +2,32 @@
   "name": "kanban",
   "type": "ui",
   "description": "Kanban — a compositional, data-agnostic board on Pragmatic drag and drop. The consumer owns columns and cards and re-renders them from its own state; the primitive wires dragging and reports intents through `onCardMove` and `onColumnMove`. ",
+  "exports": [
+    "Kanban",
+    "KanbanAddTrigger",
+    "KanbanBoard",
+    "KanbanCard",
+    "KanbanCardDescription",
+    "KanbanCardFooter",
+    "KanbanCardHandle",
+    "KanbanCardHeader",
+    "KanbanCardTitle",
+    "KanbanColumn",
+    "KanbanColumnActions",
+    "KanbanColumnContent",
+    "KanbanColumnCount",
+    "KanbanColumnFooter",
+    "KanbanColumnHandle",
+    "KanbanColumnHeader",
+    "KanbanColumnTitle",
+    "KanbanDropIndicator",
+    "KanbanDropSlot",
+    "KanbanEmpty",
+    "moveCard",
+    "moveColumn",
+    "useKanban",
+    "useKanbanColumn"
+  ],
   "dependencies": {
     "@ark-ui/react": "^5.39.1",
     "@atlaskit/pragmatic-drag-and-drop": "^3.1.0",
@@ -12,9 +38,9 @@
   "registryDependencies": [
     "badge",
     "button",
-    "drag-preview",
-    "live-region",
-    "utils"
+    "lib/drag-preview",
+    "lib/utils",
+    "live-region"
   ],
   "files": [
     {

package/registry/items/kbd.json

@@ -2,9 +2,13 @@
   "name": "kbd",
   "type": "ui",
   "description": "",
+  "exports": [
+    "Kbd",
+    "KbdGroup"
+  ],
   "dependencies": {},
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/label.json

@@ -2,9 +2,12 @@
   "name": "label",
   "type": "ui",
   "description": "Ark UI has no standalone Label primitive (its labels live inside each component's anatomy). This mirrors Radix's: a native `label` that ignores double-click text selection.",
+  "exports": [
+    "Label"
+  ],
   "dependencies": {},
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/{controllable.json → lib/controllable.json}

@@ -1,7 +1,10 @@
 {
-  "name": "controllable",
+  "name": "lib/controllable",
   "type": "lib",
   "description": "Both live on Ark's `TreeCollection` (`createTreeCollection`, re-exported) and a Popover, and own only the open state, the search query, and the value (`value`/`defaultValue`/`onValueChange`, always a `string[]`); the trigger is a focusable ",
+  "exports": [
+    "useControllable"
+  ],
   "dependencies": {},
   "registryDependencies": [],
   "files": [

package/registry/items/{data-table-adapter.json → lib/data-table-adapter.json}

@@ -1,7 +1,8 @@
 {
-  "name": "data-table-adapter",
+  "name": "lib/data-table-adapter",
   "type": "lib",
   "description": "The contract the data table parts render against. `<DataTable>` accepts any object that satisfies it, so the parts are independent of where the rows, sorting, filtering, and paging come from. The built-in engine in `@/lib/table` satisfies i",
+  "exports": [],
   "dependencies": {},
   "registryDependencies": [],
   "files": [

package/registry/items/{drag-preview.json → lib/drag-preview.json}

@@ -1,7 +1,10 @@
 {
-  "name": "drag-preview",
+  "name": "lib/drag-preview",
   "type": "lib",
   "description": "`src/components/ui/kanban.tsx` is a compositional, data-agnostic board on `@atlaskit/pragmatic-drag-and-drop` (+ `-hitbox` closest-edge/reorder index, `-auto-scroll`).",
+  "exports": [
+    "cloneDragPreview"
+  ],
   "dependencies": {
     "@atlaskit/pragmatic-drag-and-drop": "^3.1.0"
   },

package/registry/items/{form.json → lib/form.json}

@@ -1,7 +1,10 @@
 {
-  "name": "form",
+  "name": "lib/form",
   "type": "lib",
   "description": "`src/lib/form.ts` exports `useForm(defaultValues, validate, onSubmit, { mode })`: a small, dependency-free hook (values, per-field errors, validating submit) that pairs with the `Field*` parts.",
+  "exports": [
+    "useForm"
+  ],
   "dependencies": {},
   "registryDependencies": [],
   "files": [

package/registry/items/{history.json → lib/history.json}

@@ -1,7 +1,10 @@
 {
-  "name": "history",
+  "name": "lib/history",
   "type": "lib",
   "description": "Undo/redo state for any immutable value. `set` records a history entry unless `{ commit: false }` is passed (live drags, typing); `checkpoint` snapshots the present before such a sequence so one undo restores it.",
+  "exports": [
+    "useHistory"
+  ],
   "dependencies": {},
   "registryDependencies": [],
   "files": [

package/registry/items/{row-layout.json → lib/row-layout.json}

@@ -1,7 +1,12 @@
 {
-  "name": "row-layout",
+  "name": "lib/row-layout",
   "type": "lib",
   "description": "Rows-and-columns layout helpers for the Canvas primitive. A layout is `Row[]`, each row a list of items with a `width` (flex-grow weight). Drops above/below an item create a row, beside it a column; the resize handle shifts width between ne",
+  "exports": [
+    "applyRowDrop",
+    "resizeRowItems",
+    "removeRowItem"
+  ],
   "dependencies": {},
   "registryDependencies": [
     "canvas"

package/registry/items/lib/table.json

@@ -0,0 +1,19 @@
+{
+  "name": "lib/table",
+  "type": "lib",
+  "description": "A small headless table engine: column definitions, sorting, global and per-column filtering with faceted counts, pagination, row selection, and column visibility. No external dependencies.",
+  "exports": [
+    "useTable"
+  ],
+  "dependencies": {},
+  "registryDependencies": [
+    "lib/controllable"
+  ],
+  "files": [
+    {
+      "path": "lib/table.ts",
+      "content": "import * as React from \"react\"\nimport { useControllable } from \"@/lib/controllable\"\n\n/**\n * A small headless table engine: column definitions, sorting, global and\n * per-column filtering with faceted counts, pagination, row selection, and\n * column visibility. No external dependencies.\n */\n\n/* ------------------------------- Definitions ------------------------------- */\n\nexport type SortingState = { id: string; desc: boolean }[]\nexport type ColumnFiltersState = { id: string; value: unknown }[]\nexport type PaginationState = { pageIndex: number; pageSize: number }\nexport type RowSelectionState = Record<string, boolean>\nexport type VisibilityState = Record<string, boolean>\n\nexport type TableState = {\n  sorting: SortingState\n  columnFilters: ColumnFiltersState\n  globalFilter: string\n  pagination: PaginationState\n  rowSelection: RowSelectionState\n  columnVisibility: VisibilityState\n}\n\nexport type Updater<T> = T | ((previous: T) => T)\nexport type OnChange<T> = (updater: Updater<T>) => void\n\nexport type FilterFn<TData> = (row: Row<TData>, columnId: string, filterValue: unknown) => boolean\n\nexport type SortingFn<TData> = (a: Row<TData>, b: Row<TData>, columnId: string) => number\n\nexport type ColumnDef<TData, TValue = unknown> = {\n  /** Required when no `accessorKey` is given. */\n  id?: string\n  /** Read the value from this property of the row. */\n  accessorKey?: keyof TData & string\n  /** Compute the value from the row. */\n  accessorFn?: (row: TData, index: number) => TValue\n  /** Human label (view options, headers); falls back to the column id. */\n  label?: string\n  enableSorting?: boolean\n  enableHiding?: boolean\n  enableGlobalFilter?: boolean\n  filterFn?: FilterFn<TData>\n  sortingFn?: SortingFn<TData>\n}\n\n/* ---------------------------------- Runtime -------------------------------- */\n\nexport interface Column<TData, TValue = unknown> {\n  id: string\n  label?: string\n  columnDef: ColumnDef<TData, TValue>\n  accessorFn?: (row: TData, index: number) => TValue\n  getCanSort: () => boolean\n  getIsSorted: () => false | \"asc\" | \"desc\"\n  toggleSorting: (desc?: boolean) => void\n  clearSorting: () => void\n  getCanHide: () => boolean\n  getIsVisible: () => boolean\n  toggleVisibility: (visible?: boolean) => void\n  getCanFilter: () => boolean\n  getFilterValue: () => unknown\n  setFilterValue: (value: unknown) => void\n  getFacetedUniqueValues: () => Map<unknown, number>\n}\n\nexport interface Row<TData> {\n  id: string\n  index: number\n  original: TData\n  getValue: <TValue = unknown>(columnId: string) => TValue\n  getIsSelected: () => boolean\n  getCanSelect: () => boolean\n  toggleSelected: (selected?: boolean) => void\n}\n\nexport interface RowModel<TData> {\n  rows: Row<TData>[]\n}\n\nexport interface Table<TData> {\n  options: TableOptions<TData>\n  getState: () => TableState\n  getAllColumns: () => Column<TData>[]\n  getVisibleColumns: () => Column<TData>[]\n  getColumn: (id: string) => Column<TData> | undefined\n  /** All rows before filtering. */\n  getCoreRowModel: () => RowModel<TData>\n  /** Rows after global and column filters. */\n  getFilteredRowModel: () => RowModel<TData>\n  /** Filtered and sorted rows. */\n  getSortedRowModel: () => RowModel<TData>\n  /** The current page of sorted, filtered rows. */\n  getRowModel: () => RowModel<TData>\n  getFilteredSelectedRowModel: () => RowModel<TData>\n  getSelectedRowModel: () => RowModel<TData>\n  // sorting\n  setSorting: OnChange<SortingState>\n  resetSorting: () => void\n  // filtering\n  setGlobalFilter: (value: string) => void\n  setColumnFilters: OnChange<ColumnFiltersState>\n  resetColumnFilters: () => void\n  // pagination\n  setPagination: OnChange<PaginationState>\n  setPageIndex: (index: number) => void\n  setPageSize: (size: number) => void\n  getPageCount: () => number\n  getCanPreviousPage: () => boolean\n  getCanNextPage: () => boolean\n  previousPage: () => void\n  nextPage: () => void\n  // selection\n  setRowSelection: OnChange<RowSelectionState>\n  resetRowSelection: () => void\n  getIsAllPageRowsSelected: () => boolean\n  getIsSomePageRowsSelected: () => boolean\n  toggleAllPageRowsSelected: (selected?: boolean) => void\n  getIsAllRowsSelected: () => boolean\n  toggleAllRowsSelected: (selected?: boolean) => void\n  // visibility\n  setColumnVisibility: OnChange<VisibilityState>\n  resetColumnVisibility: () => void\n}\n\nexport type TableOptions<TData> = {\n  data: TData[]\n  columns: ColumnDef<TData, any>[] // eslint-disable-line @typescript-eslint/no-explicit-any\n  getRowId?: (row: TData, index: number) => string\n  enableRowSelection?: boolean | ((row: Row<TData>) => boolean)\n  /** Runs against every row when `globalFilter` is set. Defaults to a case-insensitive `includes` over globally filterable columns. */\n  globalFilterFn?: FilterFn<TData>\n  /** Uncontrolled initial values. */\n  initialState?: Partial<TableState>\n  /** Controlled values; pair each with its `on*Change` handler. */\n  state?: Partial<TableState>\n  onSortingChange?: OnChange<SortingState>\n  onColumnFiltersChange?: OnChange<ColumnFiltersState>\n  onGlobalFilterChange?: OnChange<string>\n  onPaginationChange?: OnChange<PaginationState>\n  onRowSelectionChange?: OnChange<RowSelectionState>\n  onColumnVisibilityChange?: OnChange<VisibilityState>\n  /** Keep the page index inside the page count as filters change. Defaults to true. */\n  autoResetPageIndex?: boolean\n}\n\n/* ----------------------------------- Helpers -------------------------------- */\n\nfunction defaultCompare(a: unknown, b: unknown) {\n  if (a == null && b == null) return 0\n  if (a == null) return 1\n  if (b == null) return -1\n  if (typeof a === \"number\" && typeof b === \"number\") return a - b\n  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime()\n  return String(a).localeCompare(String(b), undefined, { numeric: true, sensitivity: \"base\" })\n}\n\nfunction defaultColumnFilter<TData>(row: Row<TData>, columnId: string, filterValue: unknown) {\n  const value = row.getValue(columnId)\n  if (Array.isArray(filterValue)) return filterValue.includes(value)\n  if (filterValue == null || filterValue === \"\") return true\n  return String(value ?? \"\")\n    .toLowerCase()\n    .includes(String(filterValue).toLowerCase())\n}\n\n/* ------------------------------------ Hook ---------------------------------- */\n\nexport function useTable<TData>(options: TableOptions<TData>): Table<TData> {\n  const {\n    data,\n    columns: columnDefs,\n    getRowId,\n    enableRowSelection = true,\n    globalFilterFn,\n    initialState,\n    state: controlled,\n    autoResetPageIndex = true,\n  } = options\n\n  const [sorting, setSorting] = useControllable(\n    controlled?.sorting,\n    initialState?.sorting ?? [],\n    options.onSortingChange\n  )\n  const [columnFilters, setColumnFilters] = useControllable(\n    controlled?.columnFilters,\n    initialState?.columnFilters ?? [],\n    options.onColumnFiltersChange\n  )\n  const [globalFilter, setGlobalFilterState] = useControllable(\n    controlled?.globalFilter,\n    initialState?.globalFilter ?? \"\",\n    options.onGlobalFilterChange\n  )\n  const [pagination, setPagination] = useControllable(\n    controlled?.pagination,\n    initialState?.pagination ?? { pageIndex: 0, pageSize: 10 },\n    options.onPaginationChange\n  )\n  const [rowSelection, setRowSelection] = useControllable(\n    controlled?.rowSelection,\n    initialState?.rowSelection ?? {},\n    options.onRowSelectionChange\n  )\n  const [columnVisibility, setColumnVisibility] = useControllable(\n    controlled?.columnVisibility,\n    initialState?.columnVisibility ?? {},\n    options.onColumnVisibilityChange\n  )\n\n  const state: TableState = React.useMemo(\n    () => ({ sorting, columnFilters, globalFilter, pagination, rowSelection, columnVisibility }),\n    [sorting, columnFilters, globalFilter, pagination, rowSelection, columnVisibility]\n  )\n\n  // Keep a mutable reference so column and row methods always see fresh state\n  // without rebuilding every object on each render.\n  const tableRef = React.useRef<Table<TData>>(null!)\n\n  /* Columns */\n  const columns = React.useMemo<Column<TData>[]>(() => {\n    return columnDefs.map((def) => {\n      const id = def.id ?? def.accessorKey\n      if (!id) throw new Error(\"Every column needs an `id` or an `accessorKey`.\")\n      const accessorFn =\n        def.accessorFn ??\n        (def.accessorKey ? (row: TData) => (row as Record<string, unknown>)[def.accessorKey as string] : undefined)\n      const column: Column<TData> = {\n        id,\n        columnDef: def,\n\n        label: def.label,\n        accessorFn: accessorFn as Column<TData>[\"accessorFn\"],\n        getCanSort: () => (def.enableSorting ?? true) && !!accessorFn,\n        getIsSorted: () => {\n          const entry = tableRef.current.getState().sorting.find((s) => s.id === id)\n          return entry ? (entry.desc ? \"desc\" : \"asc\") : false\n        },\n        toggleSorting: (desc) => {\n          tableRef.current.setSorting((prev) => {\n            const current = prev.find((s) => s.id === id)\n            const nextDesc = desc ?? (current ? !current.desc : false)\n            return [{ id, desc: nextDesc }]\n          })\n        },\n        clearSorting: () => tableRef.current.setSorting((prev) => prev.filter((s) => s.id !== id)),\n        getCanHide: () => def.enableHiding ?? true,\n        getIsVisible: () => tableRef.current.getState().columnVisibility[id] !== false,\n        toggleVisibility: (visible) => {\n          tableRef.current.setColumnVisibility((prev) => ({\n            ...prev,\n            [id]: visible ?? prev[id] === false,\n          }))\n        },\n        getCanFilter: () => !!accessorFn,\n        getFilterValue: () => tableRef.current.getState().columnFilters.find((f) => f.id === id)?.value,\n        setFilterValue: (value) => {\n          tableRef.current.setColumnFilters((prev) => {\n            const rest = prev.filter((f) => f.id !== id)\n            const isEmpty =\n              value === undefined || value === null || value === \"\" || (Array.isArray(value) && value.length === 0)\n            return isEmpty ? rest : [...rest, { id, value }]\n          })\n        },\n        getFacetedUniqueValues: () => facetsRef.current.get(id) ?? new Map(),\n      }\n      return column\n    })\n  }, [columnDefs])\n\n  const columnById = React.useMemo(() => new Map(columns.map((c) => [c.id, c])), [columns])\n\n  /* Rows */\n  const coreRows = React.useMemo<Row<TData>[]>(() => {\n    return data.map((original, index) => {\n      const id = getRowId ? getRowId(original, index) : String(index)\n      const valueCache = new Map<string, unknown>()\n      const row: Row<TData> = {\n        id,\n        index,\n        original,\n        getValue: <TValue>(columnId: string) => {\n          if (valueCache.has(columnId)) return valueCache.get(columnId) as TValue\n          const column = columnById.get(columnId)\n          const value = column?.accessorFn ? column.accessorFn(original, index) : undefined\n          valueCache.set(columnId, value)\n          return value as TValue\n        },\n        getIsSelected: () => !!tableRef.current.getState().rowSelection[id],\n        getCanSelect: () => (typeof enableRowSelection === \"function\" ? enableRowSelection(row) : enableRowSelection),\n        toggleSelected: (selected) => {\n          if (!row.getCanSelect()) return\n          tableRef.current.setRowSelection((prev) => {\n            const next = { ...prev }\n            const value = selected ?? !prev[id]\n            if (value) next[id] = true\n            else delete next[id]\n            return next\n          })\n        },\n      }\n      return row\n    })\n  }, [data, getRowId, columnById, enableRowSelection])\n\n  /* Filtering */\n  const globallyFilteredRows = React.useMemo(() => {\n    if (!globalFilter) return coreRows\n    const fn: FilterFn<TData> =\n      globalFilterFn ??\n      ((row, _id, value) => {\n        const search = String(value).toLowerCase()\n        return columns.some((column) => {\n          if (!column.accessorFn || column.columnDef.enableGlobalFilter === false) return false\n          return String(row.getValue(column.id) ?? \"\")\n            .toLowerCase()\n            .includes(search)\n        })\n      })\n    return coreRows.filter((row) => fn(row, \"__global__\", globalFilter))\n  }, [coreRows, globalFilter, globalFilterFn, columns])\n\n  const filteredRows = React.useMemo(() => {\n    let rows = globallyFilteredRows\n    for (const filter of columnFilters) {\n      const column = columnById.get(filter.id)\n      if (!column) continue\n      const fn = column.columnDef.filterFn ?? defaultColumnFilter\n      rows = rows.filter((row) => fn(row, filter.id, filter.value))\n    }\n    return rows\n  }, [globallyFilteredRows, columnFilters, columnById])\n\n  /* Facets: unique value counts per column, over rows filtered by everything except that column. */\n  const facetsRef = React.useRef(new Map<string, Map<unknown, number>>())\n  facetsRef.current = React.useMemo(() => {\n    const result = new Map<string, Map<unknown, number>>()\n    for (const column of columns) {\n      if (!column.accessorFn) continue\n      let rows = globallyFilteredRows\n      for (const filter of columnFilters) {\n        if (filter.id === column.id) continue\n        const other = columnById.get(filter.id)\n        if (!other) continue\n        const fn = other.columnDef.filterFn ?? defaultColumnFilter\n        rows = rows.filter((row) => fn(row, filter.id, filter.value))\n      }\n      const counts = new Map<unknown, number>()\n      for (const row of rows) {\n        const value = row.getValue(column.id)\n        counts.set(value, (counts.get(value) ?? 0) + 1)\n      }\n      result.set(column.id, counts)\n    }\n    return result\n  }, [columns, globallyFilteredRows, columnFilters, columnById])\n\n  /* Sorting */\n  const sortedRows = React.useMemo(() => {\n    if (sorting.length === 0) return filteredRows\n    const rows = [...filteredRows]\n    rows.sort((a, b) => {\n      for (const { id, desc } of sorting) {\n        const column = columnById.get(id)\n        if (!column) continue\n        const compare = column.columnDef.sortingFn\n          ? column.columnDef.sortingFn(a, b, id)\n          : defaultCompare(a.getValue(id), b.getValue(id))\n        if (compare !== 0) return desc ? -compare : compare\n      }\n      return a.index - b.index\n    })\n    return rows\n  }, [filteredRows, sorting, columnById])\n\n  /* Pagination */\n  const pageCount = Math.max(1, Math.ceil(sortedRows.length / pagination.pageSize))\n  const pageRows = React.useMemo(() => {\n    const start = pagination.pageIndex * pagination.pageSize\n    return sortedRows.slice(start, start + pagination.pageSize)\n  }, [sortedRows, pagination])\n\n  React.useEffect(() => {\n    if (!autoResetPageIndex) return\n    if (pagination.pageIndex > pageCount - 1) {\n      setPagination((prev) => ({ ...prev, pageIndex: Math.max(0, pageCount - 1) }))\n    }\n  }, [autoResetPageIndex, pageCount, pagination.pageIndex, setPagination])\n\n  /* Table */\n  const table = React.useMemo<Table<TData>>(() => {\n    const t: Table<TData> = {\n      options,\n      getState: () => state,\n      getAllColumns: () => columns,\n      getVisibleColumns: () => columns.filter((c) => c.getIsVisible()),\n      getColumn: (id) => columnById.get(id),\n      getCoreRowModel: () => ({ rows: coreRows }),\n      getFilteredRowModel: () => ({ rows: filteredRows }),\n      getSortedRowModel: () => ({ rows: sortedRows }),\n      getRowModel: () => ({ rows: pageRows }),\n      getFilteredSelectedRowModel: () => ({\n        rows: filteredRows.filter((r) => r.getIsSelected()),\n      }),\n      getSelectedRowModel: () => ({ rows: coreRows.filter((r) => r.getIsSelected()) }),\n      setSorting,\n      resetSorting: () => setSorting([]),\n      setGlobalFilter: (value) => {\n        setGlobalFilterState(value)\n        if (autoResetPageIndex) setPagination((p) => ({ ...p, pageIndex: 0 }))\n      },\n      setColumnFilters: (updater) => {\n        setColumnFilters(updater)\n        if (autoResetPageIndex) setPagination((p) => ({ ...p, pageIndex: 0 }))\n      },\n      resetColumnFilters: () => setColumnFilters([]),\n      setPagination,\n      setPageIndex: (index) => setPagination((p) => ({ ...p, pageIndex: Math.min(Math.max(0, index), pageCount - 1) })),\n      setPageSize: (size) =>\n        setPagination((p) => ({ pageSize: size, pageIndex: Math.floor((p.pageIndex * p.pageSize) / size) })),\n      getPageCount: () => pageCount,\n      getCanPreviousPage: () => pagination.pageIndex > 0,\n      getCanNextPage: () => pagination.pageIndex < pageCount - 1,\n      previousPage: () => t.setPageIndex(pagination.pageIndex - 1),\n      nextPage: () => t.setPageIndex(pagination.pageIndex + 1),\n      setRowSelection,\n      resetRowSelection: () => setRowSelection({}),\n      getIsAllPageRowsSelected: () =>\n        pageRows.length > 0 && pageRows.every((r) => !r.getCanSelect() || r.getIsSelected()),\n      getIsSomePageRowsSelected: () => pageRows.some((r) => r.getIsSelected()) && !t.getIsAllPageRowsSelected(),\n      toggleAllPageRowsSelected: (selected) => {\n        const value = selected ?? !t.getIsAllPageRowsSelected()\n        setRowSelection((prev) => {\n          const next = { ...prev }\n          for (const row of pageRows) {\n            if (!row.getCanSelect()) continue\n            if (value) next[row.id] = true\n            else delete next[row.id]\n          }\n          return next\n        })\n      },\n      getIsAllRowsSelected: () =>\n        filteredRows.length > 0 && filteredRows.every((r) => !r.getCanSelect() || r.getIsSelected()),\n      toggleAllRowsSelected: (selected) => {\n        const value = selected ?? !t.getIsAllRowsSelected()\n        setRowSelection(() => {\n          const next: RowSelectionState = {}\n          if (value) for (const row of filteredRows) if (row.getCanSelect()) next[row.id] = true\n          return next\n        })\n      },\n      setColumnVisibility,\n      resetColumnVisibility: () => setColumnVisibility({}),\n    }\n    return t\n  }, [\n    options,\n    state,\n    columns,\n    columnById,\n    coreRows,\n    filteredRows,\n    sortedRows,\n    pageRows,\n    pageCount,\n    pagination,\n    autoResetPageIndex,\n    setSorting,\n    setGlobalFilterState,\n    setColumnFilters,\n    setPagination,\n    setRowSelection,\n    setColumnVisibility,\n  ])\n\n  tableRef.current = table\n  return table\n}\n"
+    }
+  ],
+  "docs": "## Data table\n`src/lib/table.ts` is a dependency-free headless table engine (columns, sorting, global +\ncolumn filters with faceted counts, pagination, row selection, visibility). Column config is\ndata only: `{ id | accessorKey | accessorFn, label, enableSorting, enableHiding, filterFn,\nsortingFn }`. No render functions and no markup in column definitions.\n`src/components/ui/data-table.tsx` builds compositional parts on the source-agnostic\n`DataTableInstance` contract in `src/lib/data-table-adapter.ts`: toolbar, search, faceted\nfilter, reset, view options, `DataTableTable` > `DataTableHeader` (one `DataTableHead\ncolumn=\"id\"` per column; sortable columns get the sort/hide menu with `children` as the title)\n+ `DataTableBody` (`children` is `(row) => cells`; wrap in `DataTableRow` or return a fragment\nof `DataTableCell column=\"id\"` cells), `DataTableEmpty`, select-all/select-row cells, row\nactions, pagination pieces, bulk actions. Heads and cells keyed by a hidden column render\nnothing, so visibility toggles need no extra wiring. The toolkit must not know about specific\ntable libraries (no TanStack). `src/demo/tasks/` and `src/demo/users/` are the reference\nconsumers: `columns.tsx` is pure config, `*-table.tsx` composes the markup."
+}

package/registry/items/{time.json → lib/time.json}

@@ -1,7 +1,11 @@
 {
-  "name": "time",
+  "name": "lib/time",
   "type": "lib",
   "description": "`src/components/ui/activity-feed.tsx` is a compositional timeline of events on the WAI-ARIA feed pattern (`role=\"feed\"`, focusable articles, PageUp/PageDown move, Ctrl+Home/End jump): `ActivityFeed` > `ActivityFeedGroup` > `ActivityFeedGrou",
+  "exports": [
+    "formatRelativeTime",
+    "formatCompactAge"
+  ],
   "dependencies": {},
   "registryDependencies": [],
   "files": [

package/registry/items/{utils.json → lib/utils.json}

@@ -1,7 +1,10 @@
 {
-  "name": "utils",
+  "name": "lib/utils",
   "type": "lib",
   "description": "- **Feature parity** with the shadcn original: same exported names, same props surface where Ark supports it, same visual result, same variants. - **Ark's tree wins** where the structure differs (e.g.",
+  "exports": [
+    "cn"
+  ],
   "dependencies": {
     "clsx": "^2.1.1",
     "tailwind-merge": "^3.6.0"

package/registry/items/live-region.json

@@ -2,9 +2,13 @@
   "name": "live-region",
   "type": "ui",
   "description": "Shared screen-reader announcer. `announce` re-fires even when the same text is announced twice, and `clearAfter` (ms) empties the region so stale text is not re-read when a user lands on it.",
+  "exports": [
+    "LiveRegion",
+    "useLiveRegion"
+  ],
   "dependencies": {},
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/marker.json

@@ -2,12 +2,18 @@
   "name": "marker",
   "type": "ui",
   "description": "",
+  "exports": [
+    "Marker",
+    "MarkerIcon",
+    "MarkerContent",
+    "markerVariants"
+  ],
   "dependencies": {
     "@ark-ui/react": "^5.39.1",
     "class-variance-authority": "^0.7.1"
   },
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/marquee.json

@@ -2,11 +2,20 @@
   "name": "marquee",
   "type": "ui",
   "description": "",
+  "ark": "Marquee",
+  "exports": [
+    "Marquee",
+    "MarqueeContent",
+    "MarqueeContext",
+    "MarqueeEdge",
+    "MarqueeItem",
+    "MarqueeViewport"
+  ],
   "dependencies": {
     "@ark-ui/react": "^5.39.1"
   },
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/menubar.json

@@ -2,13 +2,37 @@
   "name": "menubar",
   "type": "ui",
   "description": "Ark UI has no Menubar primitive. `Menubar` composes Ark `Menu` roots and adds the menubar behaviours Radix provides: one open menu at a time, hover switching between triggers once a menu is open, roving tabindex across triggers, and ArrowLe",
+  "ark": "Menu",
+  "exports": [
+    "Menubar",
+    "MenubarArrow",
+    "MenubarCheckboxItem",
+    "MenubarContent",
+    "MenubarContext",
+    "MenubarGroup",
+    "MenubarItem",
+    "MenubarItemIndicator",
+    "MenubarItemText",
+    "MenubarLabel",
+    "MenubarMenu",
+    "MenubarPortal",
+    "MenubarPositioner",
+    "MenubarRadioGroup",
+    "MenubarRadioItem",
+    "MenubarSeparator",
+    "MenubarShortcut",
+    "MenubarSub",
+    "MenubarSubContent",
+    "MenubarSubTrigger",
+    "MenubarTrigger"
+  ],
   "dependencies": {
     "@ark-ui/react": "^5.39.1",
     "lucide-react": "^1.41.0"
   },
   "registryDependencies": [
-    "controllable",
-    "utils"
+    "lib/controllable",
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/message.json

@@ -2,9 +2,17 @@
   "name": "message",
   "type": "ui",
   "description": "",
+  "exports": [
+    "MessageGroup",
+    "Message",
+    "MessageAvatar",
+    "MessageContent",
+    "MessageFooter",
+    "MessageHeader"
+  ],
   "dependencies": {},
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/navigation-menu.json

@@ -2,13 +2,29 @@
   "name": "navigation-menu",
   "type": "ui",
   "description": "",
+  "ark": "NavigationMenu",
+  "exports": [
+    "NavigationMenu",
+    "NavigationMenuArrow",
+    "NavigationMenuContent",
+    "NavigationMenuContext",
+    "NavigationMenuIndicator",
+    "NavigationMenuItem",
+    "NavigationMenuLink",
+    "NavigationMenuList",
+    "NavigationMenuTrigger",
+    "NavigationMenuViewport",
+    "NavigationMenuViewportPositioner",
+    "navigationMenuTriggerStyle",
+    "NavigationMenuItemIndicator"
+  ],
   "dependencies": {
     "@ark-ui/react": "^5.39.1",
     "class-variance-authority": "^0.7.1",
     "lucide-react": "^1.41.0"
   },
   "registryDependencies": [
-    "utils"
+    "lib/utils"
   ],
   "files": [
     {

package/registry/items/node-graph.json

@@ -2,6 +2,37 @@
   "name": "node-graph",
   "type": "ui",
   "description": "NodeGraph — a compositional, data-agnostic node editor in the spirit of visual scripting graphs. The consumer owns nodes and edges; the graph owns only the viewport (pan/zoom), the selection, and in-flight interactions (dragging nodes, draw",
+  "exports": [
+    "NodeGraph",
+    "NodeGraphViewport",
+    "NodeGraphBackground",
+    "NodeGraphSurface",
+    "NodeGraphEdges",
+    "NodeGraphEdge",
+    "NodeGraphConnectionLine",
+    "NodeGraphSelectionBox",
+    "NodeGraphNode",
+    "NodeGraphNodeHeader",
+    "NodeGraphNodeActions",
+    "NodeGraphNodeTitle",
+    "NodeGraphNodeSubtitle",
+    "NodeGraphNodeBody",
+    "NodeGraphNodeInputs",
+    "NodeGraphNodeOutputs",
+    "NodeGraphNodeFooter",
+    "NodeGraphPort",
+    "NodeGraphPortPin",
+    "NodeGraphPortLabel",
+    "NodeGraphControls",
+    "NodeGraphZoomInTrigger",
+    "NodeGraphZoomOutTrigger",
+    "NodeGraphFitViewTrigger",
+    "NodeGraphZoomValue",
+    "NodeGraphMinimap",
+    "NodeGraphEmpty",
+    "useNodeGraph",
+    "getBezierPath"
+  ],
   "dependencies": {
     "@ark-ui/react": "^5.39.1",
     "class-variance-authority": "^0.7.1",
@@ -9,8 +40,8 @@
   },
   "registryDependencies": [
     "button",
-    "live-region",
-    "utils"
+    "lib/utils",
+    "live-region"
   ],
   "files": [
     {