firstly 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # firstly
 
+## 0.5.1
+
+### Patch Changes
+
+- [#282](https://github.com/jycouet/firstly/pull/282) [`a93d4c8`](https://github.com/jycouet/firstly/commit/a93d4c8815da30f2c4d701ddd7e3d8cdf39fd8f5) Thanks [@jycouet](https://github.com/jycouet)! - ffRepo (svelte): leaner surface. Rename `firstOnce` → `onFirst`; remove `draft`, `first`, `insert`, `update`, `deleteMany`. List handles (`load`/`listen`/`paginate`) are now read-only - write via `.repo` (+ `addItem`/`updateItem`/`removeItem` to reconcile). Editing lives on `one`/`create()` with argless `save()`/`delete()`.
+
+  New `DemoGrid` (from `firstly/svelte`): a generic inline-CRUD table over any entity - props `entity` + `fields`, headers/placeholders from each field's `caption`.
+
 ## 0.5.0
 
 ### Minor Changes

package/esm/svelte/DemoGrid.svelte

@@ -0,0 +1,167 @@
+<script lang="ts" generics="T extends { id: string }">
+	import type { ClassType, EntityFilter, MembersOnly } from 'remult'
+
+	import { ffRepo } from './FF_Repo.svelte.js'
+
+	type Props = {
+		/** The remult entity class to CRUD. */
+		entity: ClassType<T>
+		/** Fields to show as columns / edit inputs. Headers come from each field's `caption`. */
+		fields: (keyof T & string)[]
+	}
+	let { entity, fields }: Props = $props()
+
+	// live list - any write re-emits it, so no reconcile code (entity is static config)
+	const list = ffRepo(entity).listen(() => ({}))
+
+	// the row being edited (by id), or a fresh draft for "new" - one reactive slot
+	let editingId = $state<string | null>(null)
+	const editor = ffRepo(entity).one(() => ({
+		where: { id: editingId ?? '' } as EntityFilter<T>,
+		enabled: !!editingId,
+	}))
+	const creating = $derived(!!editor.item && !editor.item.id)
+
+	// dynamic read/write of a field by key (v1: inputs are text)
+	const get = (row: T, f: keyof T & string) => (row as Record<string, unknown>)[f]
+	function setField(f: keyof T & string, value: string) {
+		if (editor.item) (editor.item as Record<string, unknown>)[f] = value
+	}
+
+	function edit(id: string) {
+		editingId = id // → editor.item loads that row
+	}
+	function add() {
+		editingId = null
+		editor.create() // blank draft into editor.item
+	}
+	function cancel() {
+		editingId = null
+		editor.item = undefined // drop the draft / stop editing
+	}
+	async function save() {
+		await editor.save() // insert (a draft) or update (the loaded row); the live list self-syncs
+		cancel()
+	}
+	async function remove(row: T) {
+		await list.repo.delete(row as Partial<MembersOnly<T>>) // raw delete via .repo; the live list drops the row
+	}
+</script>
+
+{#snippet editRow(draft: T)}
+	{#each fields as f (f)}
+		<td>
+			<input
+				placeholder={list.meta.fields.find(f)?.caption ?? f}
+				value={String(get(draft, f) ?? '')}
+				oninput={(e) => setField(f, e.currentTarget.value)}
+			/>
+		</td>
+	{/each}
+	<td class="actions">
+		<button disabled={editor.loading.saving} onclick={save}>Save</button>
+		<button onclick={cancel}>Cancel</button>
+	</td>
+{/snippet}
+
+<div class="crud">
+	<button class="new" onclick={add}>+ New</button>
+
+	<table>
+		<thead>
+			<tr>
+				{#each fields as f (f)}<th>{list.meta.fields.find(f)?.caption ?? f}</th>{/each}
+				<th></th>
+			</tr>
+		</thead>
+		<tbody>
+			{#if creating && editor.item}
+				<tr class="editing">{@render editRow(editor.item)}</tr>
+			{/if}
+			{#each list.items as row (row.id)}
+				<tr class:editing={editingId === row.id}>
+					{#if editingId === row.id && editor.item}
+						{@render editRow(editor.item)}
+					{:else}
+						{#each fields as f (f)}<td>{get(row, f)}</td>{/each}
+						<td class="actions">
+							<button onclick={() => edit(row.id)}>Edit</button>
+							<button onclick={() => remove(row)}>Delete</button>
+						</td>
+					{/if}
+				</tr>
+			{/each}
+		</tbody>
+	</table>
+
+	{#if list.loading.init}
+		<p class="muted">Loading…</p>
+	{:else if list.items.length === 0 && !creating}
+		<p class="muted">Nothing yet - hit “+ New”.</p>
+	{/if}
+</div>
+
+<style>
+	.crud {
+		font-size: 14px;
+		display: flex;
+		flex-direction: column;
+		gap: 10px;
+		align-items: start;
+	}
+	table {
+		border-collapse: collapse;
+		width: 100%;
+	}
+	th,
+	td {
+		border: 1px solid color-mix(in srgb, currentColor 18%, transparent);
+		padding: 7px 10px;
+		text-align: left;
+		vertical-align: middle;
+	}
+	th {
+		font-weight: 600;
+		background: color-mix(in srgb, currentColor 7%, transparent);
+	}
+	tr.editing {
+		background: color-mix(in srgb, currentColor 5%, transparent);
+	}
+	td.actions {
+		white-space: nowrap;
+		text-align: right;
+	}
+	td.actions button + button {
+		margin-left: 6px;
+	}
+	input {
+		width: 100%;
+		box-sizing: border-box;
+		padding: 5px 7px;
+		font: inherit;
+		color: inherit;
+		background: transparent;
+		border: 1px solid color-mix(in srgb, currentColor 30%, transparent);
+		border-radius: 6px;
+	}
+	button {
+		cursor: pointer;
+		font: inherit;
+		padding: 4px 11px;
+		color: inherit;
+		background: color-mix(in srgb, currentColor 6%, transparent);
+		border: 1px solid color-mix(in srgb, currentColor 22%, transparent);
+		border-radius: 6px;
+		transition: background 0.12s ease;
+	}
+	button:hover {
+		background: color-mix(in srgb, currentColor 14%, transparent);
+	}
+	button:disabled {
+		opacity: 0.45;
+		cursor: not-allowed;
+	}
+	.muted {
+		opacity: 0.6;
+	}
+</style>

package/esm/svelte/DemoGrid.svelte.d.ts

@@ -0,0 +1,40 @@
+import type { ClassType } from 'remult';
+declare function $$render<T extends {
+    id: string;
+}>(): {
+    props: {
+        /** The remult entity class to CRUD. */
+        entity: ClassType<T>;
+        /** Fields to show as columns / edit inputs. Headers come from each field's `caption`. */
+        fields: (keyof T & string)[];
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends {
+    id: string;
+}> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends {
+        id: string;
+    }>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends {
+        id: string;
+    }>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const DemoGrid: $$IsomorphicComponent;
+type DemoGrid<T extends {
+    id: string;
+}> = InstanceType<typeof DemoGrid<T>>;
+export default DemoGrid;

package/esm/svelte/FF_Repo.svelte.d.ts

@@ -29,12 +29,12 @@ import { type ClassType, type EntityFilter, type EntityMetadata, type EntityOrde
  * the moment it flips true - use it for search-min-length, tab visibility,
  * dependent queries, or a manual button trigger.
  *
- * Mutations on a handle (`insert`/`update`/`save`/`delete`) flip `loading` and keep
- * the result in sync - in `live` mode the liveQuery does it; in `load`/`paginate` a
- * delete is removed locally and an insert/update triggers a keep-count re-fetch; in
- * `one` any write re-fetches the single record. `save()`/`delete()` with no argument
- * target the current `item` (pairs with `one`/`create()`). For a raw write that syncs
- * nothing, use `.repo` (e.g. `ffRepo(E).repo.insert(...)`).
+ * Writes: only the record handle (`one` / `create()`) writes - argless `save()` / `delete()`
+ * act on its `item` and re-sync it. List handles (`load` / `listen` / `paginate`) don't write;
+ * go through `.repo` (the plain remult repo: `insert` / `update` / `save` / `delete` /
+ * `deleteMany`), then reflect it in a `load` / `paginate` list with the local reconcilers
+ * (`addItem` / `updateItem` / `removeItem`) - a `listen` list re-syncs itself via the liveQuery.
+ * A failed write fills `error` and re-throws.
  *
  * The factory's return type is mode-specific, so e.g. `.more()` doesn't exist on
  * a `listen()` handle. Methods also throw if reached via a cast in the wrong mode.
@@ -113,29 +113,36 @@ declare class FF_RepoHandle<Entity, O extends FF_RepoOptions<Entity> = FF_RepoOp
     hasNextPage: boolean;
     /** Aggregations for the whole query (paginate mode). `aggregates.$count` is the total row count. */
     aggregates: ExtractAggregateResult<Entity, O> | undefined;
-    first: Entity | null;
     constructor(r: Repository<Entity>, opts: Getter<Entity, O>, mode: Mode);
     /** Re-run the current query (load/paginate/one), back to the first page. */
     refresh(): Promise<void>;
     /** Load and append the next page (paginate mode). */
     more(): Promise<void>;
     /**
-     * Run `fn` once, the first time a row is known (first non-null `first`).
-     * Never fires while the result is empty - so it's robust to liveQuery emitting
-     * an empty snapshot before the data lands. Nothing to seed from an empty result.
+     * Run `fn` once - the first time a row exists (`items[0]`).
+     *
+     * The point: seed editable UI state from the latest row WITHOUT a live query
+     * clobbering in-progress edits. It fires a single time, on the first non-empty
+     * result, and never again - later ticks (an edit, a delete, a re-sort) are
+     * ignored. Empty snapshots are skipped (a liveQuery often emits one before the
+     * data lands; there is nothing to seed from an empty result).
+     *
+     * For pure derived state prefer `$derived`; reach for `onFirst` only when the
+     * seed must become independently editable (a draft the user then mutates).
+     *
+     * ```svelte
+     * const list = ffRepo(Plan).listen(() => ({ where: { ownerDid } }))
+     * let draft = $state({ title: '' })
+     * list.onFirst((latest) => (draft.title = latest.title)) // seed once, then edit freely
+     * ```
      */
-    firstOnce(fn: (latest: Entity) => void): void;
-    /** Reactive, bindable editor state seeded once from the latest row. */
-    draft<D extends Record<string, unknown>>(seed: (latest: Entity | null) => D): D;
+    onFirst(fn: (latest: Entity) => void): void;
     /** Create a new unsaved entity into the `item` slot (for an edit form). */
     create(...args: Parameters<Repository<Entity>['create']>): Entity;
-    insert(...args: Parameters<Repository<Entity>['insert']>): Promise<Entity>;
-    update(...args: Parameters<Repository<Entity>['update']>): Promise<Entity>;
-    /** Save. With no argument, saves the current `item` (e.g. a bound `one`/`create` form). */
-    save(...args: [] | Parameters<Repository<Entity>['save']>): Promise<Entity>;
-    /** Delete. With no argument, deletes the current `item`. */
-    delete(...args: [] | Parameters<Repository<Entity>['delete']>): Promise<void>;
-    deleteMany(...args: Parameters<Repository<Entity>['deleteMany']>): Promise<number>;
+    /** Save the current `item` (from `one` / `create()`). To save a specific row, use `.repo.save(row)`. */
+    save(): Promise<Entity>;
+    /** Delete the current `item`. To delete a specific row/id, use `.repo.delete(idOrRow)`. */
+    delete(): Promise<void>;
     /** Insert into `items` at `top` (default) / `bottom` / an index (`-1` = last). +1 to `$count`. */
     addItem(item: Entity, options?: {
         at?: 'top' | 'bottom' | number;
@@ -154,20 +161,20 @@ declare class FF_RepoHandle<Entity, O extends FF_RepoOptions<Entity> = FF_RepoOp
     /** Escape hatch to the underlying repo (count, findId, upsert, projections, ...). */
     get repo(): Repository<Entity>;
 }
-/** load: one-shot list; `refresh()` to re-run. No paging / aggregates. */
-export type FF_RepoLoad<Entity, O extends FF_RepoOptions<Entity> = FF_RepoOptions<Entity>> = Omit<FF_RepoHandle<Entity, O>, 'more' | 'hasNextPage' | 'aggregates'>;
-/** live: reactive subscription, auto-updates. No manual refresh / paging / aggregates / list reconcilers (the liveQuery does it). */
-export type FF_RepoLive<Entity, O extends FF_RepoOptions<Entity> = FF_RepoOptions<Entity>> = Omit<FF_RepoHandle<Entity, O>, 'refresh' | 'more' | 'hasNextPage' | 'aggregates' | 'addItem' | 'updateItem' | 'removeItem'>;
-/** paginate: `more()` / `hasNextPage` / `aggregates`. No `first`/`firstOnce`/`draft` (paged ≠ latest). */
-export type FF_RepoPaginate<Entity, O extends FF_RepoOptions<Entity> = FF_RepoOptions<Entity>> = Omit<FF_RepoHandle<Entity, O>, 'first' | 'firstOnce' | 'draft'>;
-/** one: a single reactive record in `item` (+ `first`). No paging / aggregates / list reconcilers. */
+/** load: one-shot list (`refresh()` to re-run) - a read+reconcile view. No paging/aggregates, and no `item`/`save`/`delete`/`create` (edit via `one`, write via `.repo`). */
+export type FF_RepoLoad<Entity, O extends FF_RepoOptions<Entity> = FF_RepoOptions<Entity>> = Omit<FF_RepoHandle<Entity, O>, 'more' | 'hasNextPage' | 'aggregates' | 'item' | 'save' | 'delete' | 'create'>;
+/** live: reactive subscription, auto-updates - a read view. No refresh/paging/aggregates/reconcilers (the liveQuery does it), and no `item`/`save`/`delete`/`create`. */
+export type FF_RepoLive<Entity, O extends FF_RepoOptions<Entity> = FF_RepoOptions<Entity>> = Omit<FF_RepoHandle<Entity, O>, 'refresh' | 'more' | 'hasNextPage' | 'aggregates' | 'addItem' | 'updateItem' | 'removeItem' | 'item' | 'save' | 'delete' | 'create'>;
+/** paginate: `more()` / `hasNextPage` / `aggregates` - a read+reconcile view. No `onFirst` (paged ≠ latest), and no `item`/`save`/`delete`/`create`. */
+export type FF_RepoPaginate<Entity, O extends FF_RepoOptions<Entity> = FF_RepoOptions<Entity>> = Omit<FF_RepoHandle<Entity, O>, 'onFirst' | 'item' | 'save' | 'delete' | 'create'>;
+/** one: a single reactive record in `item`. No paging / aggregates / list reconcilers. */
 export type FF_RepoOne<Entity, O extends FF_RepoOptions<Entity> = FF_RepoOptions<Entity>> = Omit<FF_RepoHandle<Entity, O>, 'more' | 'hasNextPage' | 'aggregates' | 'addItem' | 'updateItem' | 'removeItem'>;
 /**
  * Umbrella handle type - any mode. Use for a component prop that accepts a
  * `load`/`listen`/`paginate`/`one` handle (`r: FF_Repo<T>`). It exposes the surface
- * common to every mode (`items`/`item`/`loading`/`error`/`meta`/`repo` + the writes);
- * mode-specific members (`more`/`hasNextPage`/`aggregates`/`refresh`/`first`/`firstOnce`/
- * `draft`/`addItem`/`updateItem`/`removeItem`) require the matching per-mode type.
+ * common to every mode (`items`/`loading`/`error`/`meta`/`repo`); mode-specific members
+ * (`item`/`save`/`delete`/`create` on `one`; `more`/`hasNextPage`/`aggregates`/`refresh`/
+ * `onFirst`/`addItem`/`updateItem`/`removeItem`) require the matching per-mode type.
  */
 export type FF_Repo<Entity, O extends FF_RepoOptions<Entity> = FF_RepoOptions<Entity>> = FF_RepoLoad<Entity, O> | FF_RepoLive<Entity, O> | FF_RepoPaginate<Entity, O> | FF_RepoOne<Entity, O>;
 type StrictGetter<Entity, O extends FF_RepoOptions<Entity>> = () => O & Record<Exclude<keyof O, keyof FF_RepoOptions<Entity>>, never>;

package/esm/svelte/FF_Repo.svelte.js

@@ -25,7 +25,6 @@ class FF_RepoHandle {
     hasNextPage = $state(false);
     /** Aggregations for the whole query (paginate mode). `aggregates.$count` is the total row count. */
     aggregates = $state(undefined);
-    first = $derived(this.items[0] ?? null);
     constructor(r, opts, mode) {
         this.#repo = r;
         this.#opts = opts;
@@ -39,7 +38,7 @@ class FF_RepoHandle {
             }
             if (mode === 'live') {
                 // Pass orderBy so liveQuery re-sorts incrementally-added rows too;
-                // without it a freshly inserted row is appended and `first` goes stale.
+                // without it a freshly inserted row is appended and `items[0]` (the latest) goes stale.
                 const unsub = this.#repo
                     .liveQuery({ where: o.where, orderBy: o.orderBy, limit: o.limit, include: o.include })
                     .subscribe({
@@ -146,28 +145,35 @@ class FF_RepoHandle {
         }
     }
     /**
-     * Run `fn` once, the first time a row is known (first non-null `first`).
-     * Never fires while the result is empty - so it's robust to liveQuery emitting
-     * an empty snapshot before the data lands. Nothing to seed from an empty result.
+     * Run `fn` once - the first time a row exists (`items[0]`).
+     *
+     * The point: seed editable UI state from the latest row WITHOUT a live query
+     * clobbering in-progress edits. It fires a single time, on the first non-empty
+     * result, and never again - later ticks (an edit, a delete, a re-sort) are
+     * ignored. Empty snapshots are skipped (a liveQuery often emits one before the
+     * data lands; there is nothing to seed from an empty result).
+     *
+     * For pure derived state prefer `$derived`; reach for `onFirst` only when the
+     * seed must become independently editable (a draft the user then mutates).
+     *
+     * ```svelte
+     * const list = ffRepo(Plan).listen(() => ({ where: { ownerDid } }))
+     * let draft = $state({ title: '' })
+     * list.onFirst((latest) => (draft.title = latest.title)) // seed once, then edit freely
+     * ```
      */
-    firstOnce(fn) {
+    onFirst(fn) {
         let done = false;
         $effect(() => {
             if (done)
                 return;
-            const latest = this.first;
+            const latest = this.items[0];
             if (latest == null)
                 return;
             fn(latest);
             done = true;
         });
     }
-    /** Reactive, bindable editor state seeded once from the latest row. */
-    draft(seed) {
-        const values = $state(seed(null));
-        this.firstOnce((latest) => Object.assign(values, seed(latest)));
-        return values;
-    }
     /** Create a new unsaved entity into the `item` slot (for an edit form). */
     create(...args) {
         this.item = this.#repo.create(...args);
@@ -194,24 +200,14 @@ class FF_RepoHandle {
             this.loading[flag] = false;
         }
     }
-    insert(...args) {
-        return this.#write('saving', () => this.#repo.insert(...args), () => this.#resync());
-    }
-    update(...args) {
-        return this.#write('saving', () => this.#repo.update(...args), () => this.#resync());
+    /** Save the current `item` (from `one` / `create()`). To save a specific row, use `.repo.save(row)`. */
+    save() {
+        return this.#write('saving', () => this.#repo.save(this.#requireItem()), () => this.#resync());
     }
-    /** Save. With no argument, saves the current `item` (e.g. a bound `one`/`create` form). */
-    save(...args) {
-        return this.#write('saving', () => this.#repo.save(...(args.length ? args : [this.#requireItem()])), () => this.#resync());
-    }
-    /** Delete. With no argument, deletes the current `item`. */
-    delete(...args) {
-        let target;
-        return this.#write('deleting', () => {
-            const a = (args.length ? args : [this.#requireItem()]);
-            target = a[0];
-            return this.#repo.delete(...a);
-        }, () => {
+    /** Delete the current `item`. To delete a specific row/id, use `.repo.delete(idOrRow)`. */
+    delete() {
+        const target = this.#requireItem();
+        return this.#write('deleting', () => this.#repo.delete(target), () => {
             // live: liveQuery removes it. one: re-fetch (likely empty now).
             // load/paginate: drop it locally (no refetch).
             if (this.#mode === 'live')
@@ -221,15 +217,12 @@ class FF_RepoHandle {
             this.#removeLocal(target);
         });
     }
-    /** The current `item` (or throw) - backs the no-arg `save()`/`delete()` forms. */
+    /** The current `item` (or throw) - backs the argless `save()`/`delete()`. */
     #requireItem() {
         if (this.item === undefined)
-            throw new Error('FF_Repo: no `item` to save/delete - pass an explicit argument, or load one first (`one` mode or `create()`).');
+            throw new Error('FF_Repo: no `item` to save/delete - load one first (`one` mode or `create()`), or write a specific row through `.repo`.');
         return this.item;
     }
-    deleteMany(...args) {
-        return this.#write('deleting', () => this.#repo.deleteMany(...args), () => this.#resync());
-    }
     // Client-side list reconcilers (no server I/O) - reflect a change you made
     // elsewhere (e.g. via `.repo`) in the reactive `items`. `load`/`paginate` only;
     // `listen` reconciles itself via the liveQuery. `add`/`remove` also adjust

package/esm/svelte/index.d.ts

@@ -5,5 +5,6 @@ export type { InfiniteScrollOptions } from './infiniteScroll.js';
 export { SP } from './class/SP.svelte';
 export type { ParamDefinition } from './class/SP.svelte';
 export { initRemultSvelteReactivity } from './initRemultSvelteReactivity';
+export { default as DemoGrid } from './DemoGrid.svelte';
 export { default as Icon } from './ui/Icon.svelte';
 export { LibIcon_Empty, LibIcon_Forbidden, LibIcon_ChevronDown, LibIcon_ChevronUp, LibIcon_ChevronLeft, LibIcon_ChevronRight, LibIcon_Search, LibIcon_Check, LibIcon_MultiCheck, LibIcon_Add, LibIcon_MultiAdd, LibIcon_Edit, LibIcon_Eye, LibIcon_EyeOff, LibIcon_Delete, LibIcon_Cross, LibIcon_Save, LibIcon_Man, LibIcon_Woman, LibIcon_Send, LibIcon_Load, LibIcon_Settings, LibIcon_Sort, LibIcon_SortAsc, LibIcon_SortDesc, } from './ui/LibIcon.js';

package/esm/svelte/index.js

@@ -2,5 +2,6 @@ export { ffRepo } from './FF_Repo.svelte.js';
 export { infiniteScroll } from './infiniteScroll.js';
 export { SP } from './class/SP.svelte';
 export { initRemultSvelteReactivity } from './initRemultSvelteReactivity';
+export { default as DemoGrid } from './DemoGrid.svelte';
 export { default as Icon } from './ui/Icon.svelte';
 export { LibIcon_Empty, LibIcon_Forbidden, LibIcon_ChevronDown, LibIcon_ChevronUp, LibIcon_ChevronLeft, LibIcon_ChevronRight, LibIcon_Search, LibIcon_Check, LibIcon_MultiCheck, LibIcon_Add, LibIcon_MultiAdd, LibIcon_Edit, LibIcon_Eye, LibIcon_EyeOff, LibIcon_Delete, LibIcon_Cross, LibIcon_Save, LibIcon_Man, LibIcon_Woman, LibIcon_Send, LibIcon_Load, LibIcon_Settings, LibIcon_Sort, LibIcon_SortAsc, LibIcon_SortDesc, } from './ui/LibIcon.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firstly",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "type": "module",
   "description": "Firstly, an opinionated Remult setup!",
   "funding": "https://github.com/sponsors/jycouet",
@@ -40,8 +40,8 @@
     "nodemailer": "8.0.5",
     "tailwind-merge": "3.5.0",
     "tailwindcss": "4.2.2",
-    "vite-plugin-kit-routes": "1.0.5",
-    "vite-plugin-stripper": "0.10.3"
+    "vite-plugin-kit-routes": "1.0.6",
+    "vite-plugin-stripper": "0.10.4"
   },
   "sideEffects": false,
   "exports": {