runeforge 0.0.12 → 0.0.13

package/dist/components/crud/GenericCRUD.svelte

@@ -7,6 +7,7 @@
   import Update from './views/Update.svelte';
   import { AUTO_EXCLUDED } from './utils/constants.js';
   import { resolveOptions, resolveFormatter, inferType } from './utils/resolution.js';
+  import { isFilterable } from '../table/utils.js';
   import type { AttributeMetadata } from '../../types/attribute.js';
   import type {
     ActionConfiguration,
@@ -14,6 +15,13 @@
     CustomAction,
     FieldDefinition,
   } from '../../types/crud.js';
+  import type {
+    FilterSnapshot,
+    PaginatedEnvelope,
+    ServerPagination,
+    SortDirection,
+    TableQuery,
+  } from '../../types/table.js';
 
   let {
     data = undefined as Record<string, unknown> | undefined,
@@ -52,8 +60,31 @@
     form?: { error?: string } | null;
   } = $props();
 
+  function isEnvelope(value: unknown): value is PaginatedEnvelope<T> {
+    return (
+      !!value &&
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      Array.isArray((value as Record<string, unknown>).results) &&
+      typeof (value as Record<string, unknown>).count === 'number'
+    );
+  }
+
+  const rawSlice = $derived(data && dataKey ? data[dataKey] : undefined);
+  const envelope = $derived(isEnvelope(rawSlice) ? rawSlice : undefined);
   const entityData = $derived<T[]>(
-    data && dataKey ? (data[dataKey] as T[] ?? []) : []
+    envelope ? envelope.results : (Array.isArray(rawSlice) ? (rawSlice as T[]) : [])
+  );
+
+  const serverPagination = $derived<ServerPagination | undefined>(
+    envelope
+      ? {
+          page: envelope.page,
+          pageSize: envelope.pageSize,
+          totalPages: Math.max(1, Math.ceil(envelope.count / envelope.pageSize)),
+          total: envelope.count,
+        }
+      : undefined
   );
 
   const viewParam = $derived(page.url.searchParams.get('view'));
@@ -102,6 +133,72 @@
         : [])
   );
 
+  // Server-pagination mode only: GenericCRUD owns `page`/`ordering`/per-column
+  // filter query params the same way it already owns `view`/`id`, so pagination
+  // state survives reloads/direct links and `+page.svelte` never has to change.
+  const orderingParam = $derived(page.url.searchParams.get('ordering'));
+  const initialSort = $derived(
+    orderingParam
+      ? {
+          column: orderingParam.startsWith('-') ? orderingParam.slice(1) : orderingParam,
+          direction: (orderingParam.startsWith('-') ? 'desc' : 'asc') as SortDirection,
+        }
+      : undefined
+  );
+
+  const initialFilters = $derived.by<Partial<FilterSnapshot> | undefined>(() => {
+    if (!envelope) return undefined;
+    const text: Record<string, string> = {};
+    const values: Record<string, string[]> = {};
+    const dateRanges: Record<string, { from: string; to: string }> = {};
+    for (const col of resolvedColumns) {
+      if (!isFilterable(col)) continue;
+      const raw = page.url.searchParams.get(col.attribute);
+      if (raw != null) {
+        if (col.type === 'boolean') values[col.attribute] = raw.split(',').filter(Boolean);
+        else text[col.attribute] = raw;
+      }
+      const from = page.url.searchParams.get(`${col.attribute}_from`);
+      const to = page.url.searchParams.get(`${col.attribute}_to`);
+      if (from || to) dateRanges[col.attribute] = { from: from ?? '', to: to ?? '' };
+    }
+    return { text, values, dateRanges };
+  });
+
+  async function handlePaginationChange(query: TableQuery) {
+    // Local, synchronous query-string builder consumed immediately by goto();
+    // not rendered/reactive state, so plain URLSearchParams is correct here.
+    // eslint-disable-next-line svelte/prefer-svelte-reactivity
+    const params = new URLSearchParams(page.url.searchParams);
+    params.delete('view');
+    params.delete('id');
+
+    if (query.page > 1) params.set('page', String(query.page));
+    else params.delete('page');
+
+    if (query.ordering) params.set('ordering', query.ordering);
+    else params.delete('ordering');
+
+    for (const col of resolvedColumns) {
+      params.delete(col.attribute);
+      params.delete(`${col.attribute}_from`);
+      params.delete(`${col.attribute}_to`);
+    }
+    for (const [k, v] of Object.entries(query.filters.text)) {
+      if (v) params.set(k, v);
+    }
+    for (const [k, vs] of Object.entries(query.filters.values)) {
+      if (vs.length) params.set(k, vs.join(','));
+    }
+    for (const [k, r] of Object.entries(query.filters.dateRanges)) {
+      if (r.from) params.set(`${k}_from`, r.from);
+      if (r.to) params.set(`${k}_to`, r.to);
+    }
+
+    const qs = params.toString();
+    await goto(qs ? `?${qs}` : '?', { keepFocus: true, noScroll: true });
+  }
+
   const resolvedFields: FieldDefinition<T>[] = $derived(
     fields ?? (meta
       ? (Object.entries(meta) as [string, AttributeMetadata][])
@@ -221,6 +318,10 @@
     {deletion}
     {actions}
     columns={resolvedColumns}
+    pagination={serverPagination}
+    {initialSort}
+    {initialFilters}
+    onPaginationChange={handlePaginationChange}
     onCreate={navCreate}
     onEdit={navEdit}
     onView={navRead}

package/dist/components/crud/views/List.svelte

@@ -13,6 +13,7 @@
     CustomAction,
     RowAction
   } from '../../../types/crud.js';
+  import type { FilterSnapshot, ServerPagination, SortDirection, TableQuery } from '../../../types/table.js';
   import { getStrings } from '../../../i18n/context.js';
 
   const strings = getStrings();
@@ -30,6 +31,10 @@
     deletion = {} as ActionConfiguration<T>,
     actions = [] as CustomAction<T>[],
     columns = [] as ColumnDefinition<T>[],
+    pagination = undefined as ServerPagination | undefined,
+    initialSort = undefined as { column: string; direction: SortDirection } | undefined,
+    initialFilters = undefined as Partial<FilterSnapshot> | undefined,
+    onPaginationChange = undefined as ((query: TableQuery) => void) | undefined,
     onCreate,
     onEdit,
     onView,
@@ -48,6 +53,10 @@
     deletion?: ActionConfiguration<T>;
     actions?: CustomAction<T>[];
     columns?: ColumnDefinition<T>[];
+    pagination?: ServerPagination;
+    initialSort?: { column: string; direction: SortDirection };
+    initialFilters?: Partial<FilterSnapshot>;
+    onPaginationChange?: (query: TableQuery) => void;
     onCreate?: () => void;
     onEdit?: (item: T) => void;
     onView?: (item: T) => void;
@@ -68,6 +77,17 @@
   let selected = new SvelteSet<number>();
   let pendingDeletion = $state<T[] | null>(null);
 
+  // `selected` holds indices into `data`; if `data` is swapped for a different
+  // slice (page/sort/filter change in server mode) stale indices could point
+  // at unrelated rows, so clear on any data reference change.
+  let lastData: T[] | undefined;
+  $effect(() => {
+    if (data !== lastData) {
+      selected.clear();
+      lastData = data;
+    }
+  });
+
   async function runEndpointAction(endpoint: string, items: T[]) {
     await Promise.all(items.map((item) => {
       const fd = new FormData();
@@ -185,6 +205,10 @@
       selectable={allowDelete}
       {selected}
       rowActions={showRowActions ? actionsCell : undefined}
+      {pagination}
+      {initialSort}
+      {initialFilters}
+      {onPaginationChange}
     />
   </div>
 </div>

package/dist/components/crud/views/List.svelte.d.ts

@@ -1,4 +1,5 @@
 import type { ActionConfiguration, ColumnDefinition, CustomAction } from '../../../types/crud.js';
+import type { FilterSnapshot, ServerPagination, SortDirection, TableQuery } from '../../../types/table.js';
 declare function $$render<T extends object = Record<string, unknown>>(): {
     props: {
         data?: T[];
@@ -13,6 +14,13 @@ declare function $$render<T extends object = Record<string, unknown>>(): {
         deletion?: ActionConfiguration<T>;
         actions?: CustomAction<T>[];
         columns?: ColumnDefinition<T>[];
+        pagination?: ServerPagination;
+        initialSort?: {
+            column: string;
+            direction: SortDirection;
+        };
+        initialFilters?: Partial<FilterSnapshot>;
+        onPaginationChange?: (query: TableQuery) => void;
         onCreate?: () => void;
         onEdit?: (item: T) => void;
         onView?: (item: T) => void;

package/dist/components/table/ColumnFilter.svelte

@@ -48,9 +48,11 @@
     return () => calendarEl?.removeEventListener('change', handler);
   });
 
+  let debounceTimer: ReturnType<typeof setTimeout>;
   function setText(value: string) {
     filter.setText(column.attribute, value);
-    onchange?.();
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => onchange?.(), 300);
   }
   function toggle(value: string) {
     filter.toggleValue(column.attribute, value);

package/dist/components/table/PaginatedTable.svelte

@@ -3,9 +3,15 @@
   import TableBody from './TableBody.svelte';
   import Paginator from './Paginator.svelte';
   import TableHeader from './TableHeader.svelte';
-  import { SortState, FilterState } from './state.svelte.js';
-  import { distinctEntries } from './utils.js';
-  import type { IndexedRow } from '../../types/table.js';
+  import { SortState, FilterState, snapshotFilter } from './state.svelte.js';
+  import { distinctEntries, isFilterable } from './utils.js';
+  import type {
+    FilterSnapshot,
+    IndexedRow,
+    ServerPagination,
+    SortDirection,
+    TableQuery,
+  } from '../../types/table.js';
   import type { Snippet } from 'svelte';
   import type { ColumnDefinition } from '../../types/crud.js';
   import { getStrings } from '../../i18n/context.js';
@@ -20,6 +26,10 @@
     selected = $bindable(new SvelteSet<number>()),
     rowActions = undefined as Snippet<[T]> | undefined,
     actionsLabel = strings.actions,
+    pagination = undefined as ServerPagination | undefined,
+    initialSort = undefined as { column: string; direction: SortDirection } | undefined,
+    initialFilters = undefined as Partial<FilterSnapshot> | undefined,
+    onPaginationChange = undefined as ((query: TableQuery) => void) | undefined,
   }: {
     data?: T[];
     columns?: ColumnDefinition<T>[];
@@ -28,31 +38,88 @@
     selected?: SvelteSet<number>;
     rowActions?: Snippet<[T]>;
     actionsLabel?: string;
+    /** When provided, the table trusts `data` is already the requested page and
+     * defers pagination/sort/filter to `onPaginationChange` instead of computing
+     * them locally. Omit for the original fully-client-side behavior. */
+    pagination?: ServerPagination;
+    initialSort?: { column: string; direction: SortDirection };
+    initialFilters?: Partial<FilterSnapshot>;
+    onPaginationChange?: (query: TableQuery) => void;
   } = $props();
 
-  const sort = new SortState();
-  const filter = new FilterState();
+  // Intentional one-time hydration of local state from the initial prop
+  // values (not a live binding) — `svelte-check`'s state_referenced_locally
+  // warning is a false positive here.
+  const sort = new SortState(initialSort ?? null);
+  const filter = new FilterState(initialFilters ?? null);
 
-  let currentPage = $state(1);
+  let currentPage = $state(pagination?.page ?? 1);
+  let lastKnownPage = pagination?.page ?? 1;
 
-  const distinctValues = $derived(distinctEntries(data, columns));
+  const distinctValues = $derived(
+    pagination
+      ? Object.fromEntries(
+          columns
+            .filter((c) => isFilterable(c) && c.type === 'boolean')
+            .map((c) => [
+              c.attribute,
+              [
+                { key: 'true', row: {} as T },
+                { key: 'false', row: {} as T },
+              ],
+            ]),
+        )
+      : distinctEntries(data, columns)
+  );
 
   const indexed = $derived(data.map((row, index): IndexedRow<T> => ({ row, index })));
-  const filtered = $derived(indexed.filter(({ row }) => filter.matches(row, columns)));
-  const sorted = $derived(sort.apply(filtered, columns));
+  const filtered = $derived(pagination ? indexed : indexed.filter(({ row }) => filter.matches(row, columns)));
+  const sorted = $derived(pagination ? filtered : sort.apply(filtered, columns));
 
-  const totalPages = $derived(Math.ceil(sorted.length / pageSize));
-  const pageStart = $derived((currentPage - 1) * pageSize);
-  const pageData = $derived(sorted.slice(pageStart, pageStart + pageSize));
+  const effectivePageSize = $derived(pagination?.pageSize ?? pageSize);
+  const totalPages = $derived(pagination?.totalPages ?? Math.ceil(sorted.length / effectivePageSize));
+  const displayPage = $derived(pagination?.page ?? currentPage);
+  const pageStart = $derived((displayPage - 1) * effectivePageSize);
+  const pageData = $derived(pagination ? sorted : sorted.slice(pageStart, pageStart + effectivePageSize));
+  const totalCount = $derived(pagination?.total ?? sorted.length);
   const allChecked = $derived(pageData.length > 0 && pageData.every((e) => selected.has(e.index)));
   const someChecked = $derived(pageData.some((e) => selected.has(e.index)));
 
+  // Client mode only: server mode's totalPages is externally owned, clamping
+  // here would fight with URL-driven navigation while a page reload is pending.
   $effect(() => {
-    if (currentPage > totalPages && totalPages > 0) currentPage = totalPages;
+    if (!pagination && currentPage > totalPages && totalPages > 0) currentPage = totalPages;
   });
 
-  function resetPage() {
+  // Server mode: external (URL/reload) page changes -> sync local state.
+  $effect(() => {
+    if (pagination && pagination.page !== lastKnownPage) {
+      currentPage = pagination.page;
+      lastKnownPage = pagination.page;
+    }
+  });
+
+  // Server mode: local (Paginator click) page changes -> notify caller.
+  $effect(() => {
+    if (pagination && currentPage !== lastKnownPage) {
+      lastKnownPage = currentPage;
+      onPaginationChange?.(currentQuery(currentPage));
+    }
+  });
+
+  function currentQuery(page: number): TableQuery {
+    return {
+      page,
+      ordering: sort.column ? (sort.direction === 'asc' ? sort.column : `-${sort.column}`) : null,
+      filters: snapshotFilter(filter),
+    };
+  }
+
+  function handleHeaderChange() {
     currentPage = 1;
+    if (!pagination) return;
+    lastKnownPage = 1;
+    onPaginationChange?.(currentQuery(1));
   }
 
   function toggleAll() {
@@ -82,7 +149,7 @@
         {distinctValues}
         hasRowActions={!!rowActions}
         {actionsLabel}
-        onchange={resetPage}
+        onchange={handleHeaderChange}
       />
       <TableBody
         {columns}
@@ -100,7 +167,7 @@
     bind:page={currentPage}
     {totalPages}
     {pageStart}
-    {pageSize}
-    total={sorted.length}
+    pageSize={effectivePageSize}
+    total={totalCount}
   />
 </div>

package/dist/components/table/PaginatedTable.svelte.d.ts

@@ -1,4 +1,5 @@
 import { SvelteSet } from 'svelte/reactivity';
+import type { FilterSnapshot, ServerPagination, SortDirection, TableQuery } from '../../types/table.js';
 import type { Snippet } from 'svelte';
 import type { ColumnDefinition } from '../../types/crud.js';
 declare function $$render<T extends object = Record<string, unknown>>(): {
@@ -10,6 +11,16 @@ declare function $$render<T extends object = Record<string, unknown>>(): {
         selected?: SvelteSet<number>;
         rowActions?: Snippet<[T]>;
         actionsLabel?: string;
+        /** When provided, the table trusts `data` is already the requested page and
+         * defers pagination/sort/filter to `onPaginationChange` instead of computing
+         * them locally. Omit for the original fully-client-side behavior. */
+        pagination?: ServerPagination;
+        initialSort?: {
+            column: string;
+            direction: SortDirection;
+        };
+        initialFilters?: Partial<FilterSnapshot>;
+        onPaginationChange?: (query: TableQuery) => void;
     };
     exports: {};
     bindings: "selected";

package/dist/components/table/state.svelte.d.ts

@@ -1,9 +1,13 @@
 import { SvelteMap, SvelteSet } from 'svelte/reactivity';
 import type { ColumnDefinition } from '../../types/crud.js';
-import type { IndexedRow, SortDirection } from '../../types/table.js';
+import type { FilterSnapshot, IndexedRow, SortDirection } from '../../types/table.js';
 export declare class SortState {
     column: string | null;
     direction: SortDirection | null;
+    constructor(initial?: {
+        column: string | null;
+        direction: SortDirection | null;
+    } | null);
     directionFor(attribute: string): SortDirection | null;
     cycle(attribute: string): void;
     apply<T extends object>(rows: IndexedRow<T>[], columns: ColumnDefinition<T>[]): IndexedRow<T>[];
@@ -15,6 +19,7 @@ export declare class FilterState {
         from: string;
         to: string;
     }>;
+    constructor(initial?: Partial<FilterSnapshot> | null);
     textFor(attribute: string): string;
     dateRangeFor(attribute: string): {
         from: string;
@@ -28,3 +33,4 @@ export declare class FilterState {
     clear(attribute: string): void;
     matches<T extends object>(row: T, columns: ColumnDefinition<T>[]): boolean;
 }
+export declare function snapshotFilter(filter: FilterState): FilterSnapshot;

package/dist/components/table/state.svelte.js

@@ -3,6 +3,12 @@ import { cellRenderedText, compare, isFilterable } from './utils.js';
 export class SortState {
     column = $state(null);
     direction = $state(null);
+    constructor(initial) {
+        if (initial?.column) {
+            this.column = initial.column;
+            this.direction = initial.direction ?? 'desc';
+        }
+    }
     directionFor(attribute) {
         return this.column === attribute ? this.direction : null;
     }
@@ -36,6 +42,15 @@ export class FilterState {
     text = new SvelteMap();
     values = new SvelteMap();
     dateRanges = new SvelteMap();
+    constructor(initial) {
+        for (const [k, v] of Object.entries(initial?.text ?? {}))
+            this.text.set(k, v);
+        for (const [k, v] of Object.entries(initial?.values ?? {})) {
+            this.values.set(k, new SvelteSet(v));
+        }
+        for (const [k, v] of Object.entries(initial?.dateRanges ?? {}))
+            this.dateRanges.set(k, v);
+    }
     textFor(attribute) {
         return this.text.get(attribute) ?? '';
     }
@@ -107,3 +122,10 @@ export class FilterState {
         });
     }
 }
+export function snapshotFilter(filter) {
+    return {
+        text: Object.fromEntries(filter.text),
+        values: Object.fromEntries([...filter.values].map(([k, set]) => [k, [...set]])),
+        dateRanges: Object.fromEntries(filter.dateRanges),
+    };
+}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export type { BreadcrumbItem } from './types/breadcrumb.js';
 export { AttributeType } from './types/attribute.js';
 export type { AttributeMetadata, InterfaceMetadata, SelectOption, OptionsResolver, FormatterResolver } from './types/attribute.js';
-export type { CellProps, CellComponent, CellFormatter, SortDirection, IndexedRow, DistinctEntry } from './types/table.js';
+export type { CellProps, CellComponent, CellFormatter, SortDirection, IndexedRow, DistinctEntry, PaginatedEnvelope, ServerPagination, FilterSnapshot, TableQuery } from './types/table.js';
 export type { ColumnDefinition, FieldDefinition, ActionConfiguration, CustomAction, RowAction } from './types/crud.js';
 export type { RuneforgeConfig } from './config/context.js';
 export { setConfig, getConfig } from './config/context.js';
@@ -28,7 +28,7 @@ export { default as TableBody } from './components/table/TableBody.svelte';
 export { default as SortHeader } from './components/table/SortHeader.svelte';
 export { default as Paginator } from './components/table/Paginator.svelte';
 export { default as ColumnFilter } from './components/table/ColumnFilter.svelte';
-export { SortState, FilterState } from './components/table/state.svelte.js';
+export { SortState, FilterState, snapshotFilter } from './components/table/state.svelte.js';
 export { cellRenderedText, isSortable, isFilterable, compare, distinctEntries } from './components/table/utils.js';
 export { default as GenericCRUD } from './components/crud/GenericCRUD.svelte';
 export { default as Field } from './components/crud/Field.svelte';

package/dist/index.js

@@ -24,7 +24,7 @@ export { default as TableBody } from './components/table/TableBody.svelte';
 export { default as SortHeader } from './components/table/SortHeader.svelte';
 export { default as Paginator } from './components/table/Paginator.svelte';
 export { default as ColumnFilter } from './components/table/ColumnFilter.svelte';
-export { SortState, FilterState } from './components/table/state.svelte.js';
+export { SortState, FilterState, snapshotFilter } from './components/table/state.svelte.js';
 export { cellRenderedText, isSortable, isFilterable, compare, distinctEntries } from './components/table/utils.js';
 // CRUD components
 export { default as GenericCRUD } from './components/crud/GenericCRUD.svelte';

package/dist/types/table.d.ts

@@ -14,3 +14,28 @@ export interface CellProps<T extends object = Record<string, unknown>, V = unkno
 }
 export type CellComponent<T extends object = Record<string, unknown>, V = unknown> = Component<CellProps<T, V>>;
 export type CellFormatter<T extends object = Record<string, unknown>, V = unknown> = (value: CellProps<T, V>['value'], row: CellProps<T, V>['row']) => string;
+export interface PaginatedEnvelope<T> {
+    results: T[];
+    count: number;
+    page: number;
+    pageSize: number;
+}
+export interface ServerPagination {
+    page: number;
+    totalPages: number;
+    total: number;
+    pageSize: number;
+}
+export interface FilterSnapshot {
+    text: Record<string, string>;
+    values: Record<string, string[]>;
+    dateRanges: Record<string, {
+        from: string;
+        to: string;
+    }>;
+}
+export interface TableQuery {
+    page: number;
+    ordering: string | null;
+    filters: FilterSnapshot;
+}

package/package.json

@@ -1,81 +1,79 @@
 {
-	"name": "runeforge",
-	"version": "0.0.12",
-	"description": "SvelteKit toolkit for building metadata-driven CRUD interfaces with tables, forms, and actions",
-	"license": "MIT",
-	"author": "Ezequiel Puerta",
-	"keywords": [
-		"svelte",
-		"sveltekit",
-		"crud",
-		"table",
-		"form",
-		"daisyui",
-		"tailwindcss",
-		"ui"
-	],
-	"scripts": {
-		"dev": "vite dev",
-		"build": "vite build && npm run prepack",
-		"preview": "vite preview",
-		"prepare": "svelte-kit sync || echo ''",
-		"prepack": "svelte-kit sync && svelte-package && publint",
-		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
-		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
-		"test": "pnpm run test:unit && pnpm run test:e2e",
-		"test:unit": "vitest run",
-		"test:unit:watch": "vitest",
-		"test:e2e": "playwright test",
-		"lint": "prettier --check . && eslint .",
-		"format": "prettier --write ."
-	},
-	"files": [
-		"dist",
-		"!dist/**/*.test.*",
-		"!dist/**/*.spec.*"
-	],
-	"sideEffects": [
-		"**/*.css"
-	],
-	"svelte": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"type": "module",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"svelte": "./dist/index.js"
-		}
-	},
-	"peerDependencies": {
-		"@sveltejs/kit": "^2.0.0",
-		"daisyui": "^5.0.0",
-		"svelte": "^5.0.0",
-		"tailwindcss": "^4.0.0"
-	},
-	"devDependencies": {
-		"@eslint/js": "^10.0.1",
-		"@playwright/test": "^1.60.0",
-		"@sveltejs/adapter-auto": "^7.0.1",
-		"@sveltejs/kit": "^2.63.0",
-		"@sveltejs/package": "^2.5.8",
-		"@sveltejs/vite-plugin-svelte": "^7.1.2",
-		"@tailwindcss/vite": "^4.3.1",
-		"@types/node": "^22",
-		"daisyui": "^5.5.23",
-		"eslint": "^10.4.1",
-		"eslint-config-prettier": "^10.1.8",
-		"eslint-plugin-svelte": "^3.19.0",
-		"globals": "^17.6.0",
-		"prettier": "^3.8.3",
-		"prettier-plugin-svelte": "^4.1.0",
-		"publint": "^0.3.21",
-		"svelte": "^5.56.1",
-		"svelte-bootstrap-icons": "^3.3.0",
-		"svelte-check": "^4.6.0",
-		"tailwindcss": "^4.3.1",
-		"typescript": "^6.0.3",
-		"typescript-eslint": "^8.60.1",
-		"vite": "^8.0.16",
-		"vitest": "^4.1.8"
-	}
-}
+  "name": "runeforge",
+  "version": "0.0.13",
+  "description": "SvelteKit toolkit for building metadata-driven CRUD interfaces with tables, forms, and actions",
+  "license": "MIT",
+  "author": "Ezequiel Puerta",
+  "keywords": [
+    "svelte",
+    "sveltekit",
+    "crud",
+    "table",
+    "form",
+    "daisyui",
+    "tailwindcss",
+    "ui"
+  ],
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "@sveltejs/kit": "^2.0.0",
+    "daisyui": "^5.0.0",
+    "svelte": "^5.0.0",
+    "tailwindcss": "^4.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.60.0",
+    "@sveltejs/adapter-auto": "^7.0.1",
+    "@sveltejs/kit": "^2.63.0",
+    "@sveltejs/package": "^2.5.8",
+    "@sveltejs/vite-plugin-svelte": "^7.1.2",
+    "@tailwindcss/vite": "^4.3.1",
+    "@types/node": "^22",
+    "daisyui": "^5.5.23",
+    "eslint": "^10.4.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-svelte": "^3.19.0",
+    "globals": "^17.6.0",
+    "prettier": "^3.8.3",
+    "prettier-plugin-svelte": "^4.1.0",
+    "publint": "^0.3.21",
+    "svelte": "^5.56.1",
+    "svelte-bootstrap-icons": "^3.3.0",
+    "svelte-check": "^4.6.0",
+    "tailwindcss": "^4.3.1",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.60.1",
+    "vite": "^8.0.16",
+    "vitest": "^4.1.8"
+  },
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build && npm run prepack",
+    "preview": "vite preview",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "test": "pnpm run test:unit && pnpm run test:e2e",
+    "test:unit": "vitest run",
+    "test:unit:watch": "vitest",
+    "test:e2e": "playwright test",
+    "lint": "prettier --check . && eslint .",
+    "format": "prettier --write ."
+  }
+}