@flickfyi/flkr 0.0.140 → 0.0.146

package/node_modules/@flickfyi/core/tests/kowalski-store.test.tsx

@@ -0,0 +1,514 @@
+// @vitest-environment happy-dom
+import {
+	act,
+	cleanup,
+	fireEvent,
+	render,
+	renderHook,
+	screen,
+	waitFor,
+} from '@testing-library/react'
+import { Activity, createElement } from 'react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { z } from 'zod/v4'
+
+import { kowalskiCatalog } from '~/kowalski/catalog'
+import { useConfiguredFeature } from '~/kowalski/use-configured-feature'
+import { useFeatureStore } from '~/kowalski/use-feature-store'
+
+afterEach(() => {
+	cleanup()
+	vi.unstubAllGlobals()
+})
+
+describe('Kowalski Quantum persistence', () => {
+	it('recovers an initial open failure by manual retry without remounting or reopening on rerender', async () => {
+		const native = nativeStore({ configuration: null, progress: 2 })
+		const subscribe = vi.spyOn(native.store, 'subscribe')
+		const openStore = vi
+			.fn<() => Promise<typeof native.store>>()
+			.mockRejectedValueOnce(new Error('Open failed'))
+			.mockResolvedValue(native.store)
+		vi.stubGlobal('Quantum', { openStore })
+		const hook = renderHook(() =>
+			useFeatureStore({
+				initialState: { configuration: null, progress: 0 },
+				name: 'RetryOpen',
+				schema: kowalskiCatalog.goal.storeSchema,
+			})
+		)
+		await waitFor(() =>
+			expect(hook.result.current.error).toBe(
+				'Could not load this feature. Please try again.'
+			)
+		)
+		expect(hook.result.current.ready).toBe(false)
+		expect(hook.result.current.retry).toBeTypeOf('function')
+		hook.rerender()
+		expect(openStore).toHaveBeenCalledOnce()
+		act(() => hook.result.current.retry?.())
+		await waitFor(() => expect(hook.result.current.ready).toBe(true))
+		expect(hook.result.current.value.progress).toBe(2)
+		expect(hook.result.current.error).toBeUndefined()
+		expect(hook.result.current.retry).toBeUndefined()
+		act(() => hook.result.current.set({ progress: 3 }))
+		await waitFor(() => expect(hook.result.current.value.progress).toBe(3))
+		hook.rerender()
+		expect(openStore).toHaveBeenCalledTimes(2)
+		expect(subscribe).toHaveBeenCalledOnce()
+	})
+
+	it('preserves its last good value after a malformed snapshot and recovers by retrying', async () => {
+		const native = nativeStore({ configuration: null, progress: 2 })
+		const subscribe = vi.spyOn(native.store, 'subscribe')
+		const openStore = vi.fn(async () => native.store)
+		vi.stubGlobal('Quantum', { openStore })
+		const hook = renderHook(() =>
+			useFeatureStore({
+				initialState: { configuration: null, progress: 0 },
+				name: 'RetrySnapshot',
+				schema: kowalskiCatalog.goal.storeSchema,
+			})
+		)
+		await waitFor(() => expect(hook.result.current.ready).toBe(true))
+		await act(async () =>
+			subscribe.mock.calls[0]?.[0]({
+				rawValue: { configuration: null, progress: 'invalid' },
+				version: 0,
+			})
+		)
+		await waitFor(() =>
+			expect(hook.result.current.error).toBe(
+				'Could not load this feature. Please try again.'
+			)
+		)
+		expect(hook.result.current.value.progress).toBe(2)
+		expect(hook.result.current.ready).toBe(false)
+		act(() => expect(hook.result.current.set({ progress: 3 })).toBe(false))
+		hook.rerender()
+		expect(subscribe).toHaveBeenCalledOnce()
+		act(() => hook.result.current.retry?.())
+		await waitFor(() => expect(hook.result.current.ready).toBe(true))
+		expect(hook.result.current.value.progress).toBe(2)
+		expect(hook.result.current.error).toBeUndefined()
+		expect(hook.result.current.retry).toBeUndefined()
+		expect(openStore).toHaveBeenCalledTimes(2)
+		expect(subscribe).toHaveBeenCalledTimes(2)
+	})
+
+	it('retries a rejected configuration revision explicitly without retrying in a loop', async () => {
+		const schema = kowalskiCatalog.note.storeSchema
+		const seed = schema.parse({ body: { value: 'Seed' }, title: { value: 'Before' } })
+		const native = nativeStore({ ...seed, configuration: seed, configurationRevision: 1 })
+		const save = native.store.setAsync.bind(native.store)
+		native.store.setAsync = vi.fn(save).mockRejectedValueOnce(new Error('SQLite failed'))
+		vi.stubGlobal('Quantum', { openStore: async () => native.store })
+		const hook = renderHook(() =>
+			useConfiguredFeature({
+				name: 'NoteRetry',
+				revision: 2,
+				schema,
+				scope: 'private',
+				seed: { ...seed, title: { value: 'After' } },
+			})
+		)
+		await waitFor(() => expect(hook.result.current.error).toContain('Could not save'))
+		expect(native.value().title.value).toBe('Before')
+		hook.rerender()
+		expect(native.store.setAsync).toHaveBeenCalledOnce()
+		expect(hook.result.current.retry).toBeTypeOf('function')
+		act(() => hook.result.current.retry?.())
+		await waitFor(() => expect(native.value().configurationRevision).toBe(2))
+		expect(native.value().title.value).toBe('After')
+		expect(native.store.setAsync).toHaveBeenCalledTimes(2)
+		await waitFor(() => expect(hook.result.current.error).toBeUndefined())
+		expect(hook.result.current.retry).toBeUndefined()
+	})
+
+	it('stores authored configuration as a structured value', async () => {
+		const schema = kowalskiCatalog.note.storeSchema
+		const seed = schema.parse({ body: { value: 'Writing' }, title: { value: 'Title' } })
+		vi.stubGlobal('Quantum', {
+			openStore: async ({ initialState }: { initialState: typeof seed }) =>
+				nativeStore(initialState).store,
+		})
+		const hook = renderHook(() =>
+			useConfiguredFeature({
+				name: 'Structured',
+				revision: 1,
+				schema,
+				scope: 'private',
+				seed,
+			})
+		)
+		await waitFor(() => expect(hook.result.current.ready).toBe(true))
+		expect(hook.result.current.value.configuration).toEqual(seed)
+	})
+	it('shows rejection rollback after an Activity resubscribes through a new native proxy', async () => {
+		const native = nativeStore({ configuration: null, progress: 2 })
+		let opens = 0
+		let rejectWrite: ((error: Error) => void) | undefined
+		vi.stubGlobal('Quantum', {
+			async openStore() {
+				opens++
+				return {
+					...native.store,
+					setAsync: () =>
+						new Promise<{ rawValue: unknown; version: number }>((_resolve, reject) => {
+							rejectWrite = reject
+						}),
+				}
+			},
+		})
+		function Probe() {
+			const store = useFeatureStore({
+				initialState: native.value(),
+				name: 'ActivityGoal',
+				schema: kowalskiCatalog.goal.storeSchema,
+			})
+			return createElement(
+				'div',
+				{},
+				createElement('span', {}, String(store.value.progress)),
+				createElement('span', {}, store.error),
+				createElement(
+					'button',
+					{ disabled: !store.ready, onClick: () => store.set({ progress: 3 }) },
+					'Add'
+				)
+			)
+		}
+		const tree = (mode: 'visible' | 'hidden') =>
+			createElement(Activity, { mode }, createElement(Probe))
+		const view = render(tree('visible'))
+		await waitFor(() =>
+			expect(screen.getByRole('button').hasAttribute('disabled')).toBe(false)
+		)
+		fireEvent.click(screen.getByRole('button'))
+		expect(screen.getByText('3')).toBeTruthy()
+		await act(async () => view.rerender(tree('hidden')))
+		await act(async () => view.rerender(tree('visible')))
+		await waitFor(() => expect(opens).toBe(2))
+		await act(async () => rejectWrite?.(new Error('Old proxy write rejected')))
+		await waitFor(() =>
+			expect(
+				screen.getByText('Could not save this change. Please try again.')
+			).toBeTruthy()
+		)
+		expect(screen.getByText('2')).toBeTruthy()
+	})
+	it('retries a configuration independently after rebinding to another store', async () => {
+		const schema = kowalskiCatalog.note.storeSchema
+		const seed = schema.parse({ body: { value: 'Seed' }, title: { value: 'Before' } })
+		const initial = { ...seed, configuration: seed, configurationRevision: 1 }
+		const a = nativeStore(initial)
+		const b = nativeStore(initial)
+		a.store.setAsync = vi.fn().mockRejectedValue(new Error('Rejected A'))
+		vi.stubGlobal('Quantum', {
+			openStore: async ({ name }: { name: string }) => (name === 'A' ? a.store : b.store),
+		})
+		const hook = renderHook(
+			({ name }) =>
+				useConfiguredFeature({
+					name,
+					revision: 2,
+					schema,
+					scope: 'private',
+					seed: { ...seed, title: { value: 'After' } },
+				}),
+			{ initialProps: { name: 'A' } }
+		)
+		await waitFor(() => expect(hook.result.current.error).toContain('Could not save'))
+		hook.rerender({ name: 'B' })
+		await waitFor(() => expect(b.value().title.value).toBe('After'))
+		expect(a.store.setAsync).toHaveBeenCalledOnce()
+	})
+	it.each([false, true])(
+		'disables unconfirmable or read-only writes (read-only=%s)',
+		async readOnly => {
+			const native = nativeStore({ configuration: null, progress: 2 })
+			const store = {
+				...native.store,
+				canWrite: !readOnly,
+				setAsync: readOnly ? native.store.setAsync : undefined,
+			}
+			vi.stubGlobal('Quantum', { openStore: async () => store })
+			const hook = renderHook(() =>
+				useFeatureStore({
+					initialState: native.value(),
+					name: 'ReadOnly',
+					schema: kowalskiCatalog.goal.storeSchema,
+				})
+			)
+			await waitFor(() =>
+				expect(hook.result.current.error).toContain(
+					readOnly ? 'read-only' : 'Update Flick'
+				)
+			)
+			expect(hook.result.current.ready).toBe(false)
+			act(() => expect(hook.result.current.set({ progress: 3 })).toBe(false))
+			expect(native.value().progress).toBe(2)
+		}
+	)
+	it('retains rapid taps while native write acknowledgments arrive later', async () => {
+		let persisted = { configuration: null, configurationRevision: 0, progress: 2 }
+		let notify: ((raw: { rawValue: unknown; version: number }) => void) | undefined
+		const pending: Array<{
+			patch: Partial<typeof persisted>
+			resolve: (raw: { rawValue: unknown; version: number }) => void
+		}> = []
+		vi.stubGlobal('Quantum', {
+			openStore: async () => ({
+				set() {},
+				setAsync: (patch: Partial<typeof persisted>) =>
+					new Promise<{ rawValue: unknown; version: number }>(resolve => {
+						pending.push({ patch, resolve })
+					}),
+				subscribe(listener: typeof notify) {
+					notify = listener
+					listener?.({ rawValue: persisted, version: 0 })
+					return () => {}
+				},
+			}),
+		})
+		const hook = renderHook(() =>
+			useFeatureStore({
+				initialState: persisted,
+				name: 'DeferredGoal',
+				schema: kowalskiCatalog.goal.storeSchema,
+			})
+		)
+		await waitFor(() => expect(hook.result.current.ready).toBe(true))
+		act(() => {
+			for (let index = 0; index < 3; index++) {
+				hook.result.current.set(current => ({ progress: current.progress + 1 }))
+			}
+		})
+		await act(async () => {
+			const write = pending.shift()
+			persisted = { ...persisted, ...write?.patch }
+			const raw = { rawValue: persisted, version: 0 }
+			notify?.(raw)
+			write?.resolve(raw)
+		})
+		expect(hook.result.current.value.progress).toBe(5)
+		act(() => hook.result.current.set(current => ({ progress: current.progress + 1 })))
+		for (let index = 0; index < 5 && pending.length; index++) {
+			await act(async () => {
+				const write = pending.shift()
+				persisted = { ...persisted, ...write?.patch }
+				const raw = { rawValue: persisted, version: 0 }
+				notify?.(raw)
+				write?.resolve(raw)
+			})
+		}
+		expect(persisted.progress).toBe(6)
+		expect(hook.result.current.value.progress).toBe(6)
+	})
+	it('rolls back a rejected asynchronous save and exposes the failure', async () => {
+		const native = nativeStore({ configuration: null, progress: 2 })
+		native.store.setAsync = vi.fn().mockRejectedValue(new Error('SQLite failed'))
+		vi.stubGlobal('Quantum', { openStore: async () => native.store })
+		const hook = renderHook(() =>
+			useFeatureStore({
+				initialState: native.value(),
+				name: 'Rejected',
+				schema: kowalskiCatalog.goal.storeSchema,
+			})
+		)
+		await waitFor(() => expect(hook.result.current.ready).toBe(true))
+		act(() => hook.result.current.set({ progress: 3 }))
+		expect(hook.result.current.value.progress).toBe(3)
+		await waitFor(() => expect(hook.result.current.error).toContain('Could not save'))
+		expect(hook.result.current.value.progress).toBe(2)
+	})
+	it('accepts a successful merged text value rather than waiting for an exact echo', async () => {
+		const schema = z.object({
+			body: z.string(),
+			configuration: z.null(),
+			title: z.string(),
+		})
+		const native = nativeStore({ body: 'Seed', configuration: null, title: 'Before' })
+		native.store.setAsync = async () => {
+			native.store.set({ body: 'Peer + mine' })
+			return { rawValue: native.value(), version: 0 }
+		}
+		vi.stubGlobal('Quantum', { openStore: async () => native.store })
+		const hook = renderHook(() =>
+			useFeatureStore({ initialState: native.value(), name: 'Merged', schema })
+		)
+		await waitFor(() => expect(hook.result.current.ready).toBe(true))
+		act(() => hook.result.current.set({ body: 'Mine' }))
+		await waitFor(() => expect(hook.result.current.value.body).toBe('Peer + mine'))
+		act(() => native.store.set({ body: 'Later peer edit' }))
+		await waitFor(() => expect(hook.result.current.value.body).toBe('Later peer edit'))
+	})
+	it('preserves a conflicting live Trip range without consuming the new revision', async () => {
+		const schema = kowalskiCatalog.trip.storeSchema
+		const seed = schema.parse({
+			endDate: { value: '2026-10-25' },
+			startDate: { value: '2026-10-20' },
+		})
+		const native = nativeStore({
+			...seed,
+			configuration: seed,
+			configurationRevision: 1,
+			startDate: { value: '2026-10-24' },
+		})
+		vi.stubGlobal('Quantum', { openStore: async () => native.store })
+		const hook = renderHook(() =>
+			useConfiguredFeature({
+				name: 'Trip',
+				revision: 2,
+				schema,
+				scope: 'private',
+				seed: { ...seed, endDate: { value: '2026-10-22' } },
+			})
+		)
+		await waitFor(() => expect(hook.result.current.error).toContain('conflicts'))
+		expect(native.value()).toMatchObject({
+			configurationRevision: 1,
+			endDate: { value: '2026-10-25' },
+			startDate: { value: '2026-10-24' },
+		})
+		act(() => hook.result.current.set({ startDate: { value: '2026-10-21' } }))
+		await waitFor(() =>
+			expect(native.value()).toMatchObject({
+				configurationRevision: 2,
+				endDate: { value: '2026-10-22' },
+				startDate: { value: '2026-10-21' },
+			})
+		)
+	})
+	it('applies only changed configuration fields and rejects an older installed configuration', async () => {
+		const schema = kowalskiCatalog.note.storeSchema
+		const original = schema.parse({ body: { value: 'Seed' }, title: { value: 'Before' } })
+		const native = nativeStore({
+			...original,
+			body: { value: 'My writing' },
+			configuration: original,
+			configurationRevision: 1,
+			title: { value: 'My title' },
+		})
+		vi.stubGlobal('Quantum', { openStore: async () => native.store })
+		const hook = renderHook(
+			({ revision, title }) =>
+				useConfiguredFeature({
+					name: 'NoteOne',
+					revision,
+					schema,
+					scope: 'private',
+					seed: schema.parse({ body: { value: 'Seed' }, title: { value: title } }),
+				}),
+			{ initialProps: { revision: 2, title: 'After' } }
+		)
+		await waitFor(() => expect(native.value().title.value).toBe('After'))
+		expect(native.value().body.value).toBe('My writing')
+		hook.rerender({ revision: 1, title: 'Before' })
+		await waitFor(() => expect(hook.result.current.ready).toBe(true))
+		expect(native.value().title.value).toBe('After')
+		expect(native.value().configurationRevision).toBe(2)
+	})
+	it('waits for saved data before allowing a mutation and retains untouched fields', async () => {
+		let resolveOpen:
+			| ((store: ReturnType<typeof nativeStore>['store']) => void)
+			| undefined
+		const opening = new Promise<ReturnType<typeof nativeStore>['store']>(resolve => {
+			resolveOpen = resolve
+		})
+		const native = nativeStore({ completed_sleepingBag: true, configuration: null })
+		vi.stubGlobal('Quantum', { openStore: () => opening })
+		const { result } = renderHook(() =>
+			useFeatureStore({
+				initialState: { configuration: null },
+				name: 'KowalskiChecklist',
+				schema: kowalskiCatalog.checklist.storeSchema,
+			})
+		)
+		expect(result.current.ready).toBe(false)
+		act(() => {
+			expect(result.current.set({ completed_tent: true })).toBe(false)
+		})
+		resolveOpen?.(native.store)
+		await waitFor(() => expect(result.current.ready).toBe(true))
+		expect(result.current.value.completed_sleepingBag).toBe(true)
+		act(() => result.current.set({ completed_tent: true }))
+		await waitFor(() =>
+			expect(native.value()).toEqual({
+				completed_sleepingBag: true,
+				completed_tent: true,
+				configuration: null,
+			})
+		)
+	})
+
+	it('reads its own rapid writes without losing increments before subscription parsing completes', async () => {
+		const native = nativeStore({ configuration: null, progress: 2 })
+		vi.stubGlobal('Quantum', { openStore: async () => native.store })
+		const { result } = renderHook(() =>
+			useFeatureStore({
+				initialState: { configuration: null, progress: 0 },
+				name: 'KowalskiGoal',
+				schema: kowalskiCatalog.goal.storeSchema,
+			})
+		)
+		await waitFor(() => expect(result.current.ready).toBe(true))
+		act(() => {
+			result.current.set(current => ({ progress: current.progress + 1 }))
+			result.current.set(current => ({ progress: current.progress + 1 }))
+			result.current.set(current => ({ progress: current.progress + 1 }))
+		})
+		expect(native.value().progress).toBe(5)
+		await waitFor(() => expect(result.current.value.progress).toBe(5))
+	})
+
+	it('reopens the same store without resetting it from new initial values', async () => {
+		const native = nativeStore({ configuration: null, progress: 7 })
+		vi.stubGlobal('Quantum', { openStore: async () => native.store })
+		const first = renderHook(() =>
+			useFeatureStore({
+				initialState: { configuration: null, progress: 0 },
+				name: 'KowalskiGoal',
+				schema: kowalskiCatalog.goal.storeSchema,
+			})
+		)
+		await waitFor(() => expect(first.result.current.ready).toBe(true))
+		first.unmount()
+		const second = renderHook(() =>
+			useFeatureStore({
+				initialState: { configuration: null, progress: 99 },
+				name: 'KowalskiGoal',
+				schema: kowalskiCatalog.goal.storeSchema,
+			})
+		)
+		await waitFor(() => expect(second.result.current.ready).toBe(true))
+		expect(second.result.current.value.progress).toBe(7)
+	})
+})
+
+function nativeStore<T extends Record<string, unknown>>(initial: T) {
+	let value = initial
+	const listeners = new Set<(raw: { rawValue: unknown; version: number }) => void>()
+	return {
+		store: {
+			set(patch: Partial<T>) {
+				value = { ...value, ...patch }
+				for (const listener of listeners) {
+					listener({ rawValue: value, version: 0 })
+				}
+			},
+			async setAsync(patch: Partial<T>) {
+				this.set(patch)
+				return { rawValue: value, version: 0 }
+			},
+			subscribe(listener: (raw: { rawValue: unknown; version: number }) => void) {
+				listeners.add(listener)
+				listener({ rawValue: value, version: 0 })
+				return () => {
+					listeners.delete(listener)
+				}
+			},
+		},
+		value: () => value,
+	}
+}

package/node_modules/@flickfyi/core/tests/preview-build.test.ts

@@ -25,7 +25,7 @@ const previews = Object.entries(config.environments ?? {})
 		const filename = build.lib.fileName('iife', basename(build.lib.entry, '.tsx'))
 		return { entry: build.lib.entry, filename, output: resolve(build.outDir, filename) }
 	})
-const canonicalExamples = globSync('examples/parrott/*/*.tsx', { cwd: packageRoot })
+const canonicalExamples = globSync(['examples/parrott/*/*.tsx', 'examples/kowalski/*/*.tsx'], { cwd: packageRoot })
 	.filter(entry => basename(dirname(entry)) === basename(entry, '.tsx'))
 	.map(entry => resolve(packageRoot, entry))
 

package/node_modules/@flickfyi/core/tests/quantum-use-store.test.ts

@@ -5,7 +5,7 @@ import { act, cleanup, renderHook, waitFor } from '@testing-library/react'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { z } from 'zod'
 
-import { createQuantumStoreAdapter, usePublicStore } from '../src/quantum/use-store'
+import { createQuantumStoreAdapter, usePublicStore } from '~/quantum/use-store'
 
 afterEach(() => {
 	cleanup()
@@ -120,6 +120,58 @@ function isTestState(value: unknown): value is TestState {
 }
 
 describe('createQuantumStoreAdapter', () => {
+	it('ignores a stale parse failure after accepting a newer snapshot', async () => {
+		const native = createTestStore()
+		const pending = createDeferred<TestState>()
+		const onLoadError = vi.fn()
+		const adapter = createQuantumStoreAdapter(
+			async () => native.store,
+			{ count: 0 },
+			raw =>
+				raw.rawValue === 'delayed failure' ? pending.promise : parseTestSnapshot(raw),
+			onLoadError
+		)
+		const unsubscribe = adapter.subscribe(vi.fn())
+		await waitFor(() => expect(native.store.subscribe).toHaveBeenCalledOnce())
+		native.store.subscribe.mock.calls[0]?.[0]({ rawValue: 'delayed failure', version: 0 })
+		native.emit({ count: 2 })
+		await Promise.resolve()
+		pending.reject(new Error('Stale malformed payload'))
+		await Promise.allSettled([pending.promise])
+		await Promise.resolve()
+		expect(adapter.getSnapshot()).toEqual({ count: 2 })
+		expect(onLoadError).not.toHaveBeenCalled()
+		unsubscribe()
+	})
+
+	it('retries by replacing one subscription and ignores failures from the old generation', async () => {
+		const native = createTestStore()
+		const pending = createDeferred<TestState>()
+		const onLoadError = vi.fn()
+		const adapter = createQuantumStoreAdapter(
+			async () => native.store,
+			{ count: 0 },
+			raw =>
+				raw.rawValue === 'delayed failure' ? pending.promise : parseTestSnapshot(raw),
+			onLoadError
+		)
+		const unsubscribe = adapter.subscribe(vi.fn())
+		await waitFor(() => expect(native.store.subscribe).toHaveBeenCalledOnce())
+		native.store.subscribe.mock.calls[0]?.[0]({ rawValue: 'delayed failure', version: 0 })
+		adapter.retry()
+		await waitFor(() => expect(native.store.subscribe).toHaveBeenCalledTimes(2))
+		expect(native.unsubscribe).toHaveBeenCalledOnce()
+		native.emit({ count: 3 })
+		await Promise.resolve()
+		pending.reject(new Error('Old generation'))
+		await Promise.allSettled([pending.promise])
+		await Promise.resolve()
+		expect(adapter.getSnapshot()).toEqual({ count: 3 })
+		expect(onLoadError).not.toHaveBeenCalled()
+		unsubscribe()
+		expect(native.unsubscribe).toHaveBeenCalledTimes(2)
+	})
+
 	it('preserves an undefined snapshot until a legacy store hydrates', async () => {
 		const open = createDeferred<ReturnType<typeof createTestStore>['store']>()
 		const store = createTestStore()

package/node_modules/@flickfyi/core/tests/verify-tsgo-assets.test.ts

@@ -21,7 +21,7 @@ it.each(['package.tsgo.json', 'tsgo.package.json'])(
   '%s keeps the UI layer after its Core dependency with each module owned once',
   file => {
     const { runtime } = JSON.parse(readFileSync(resolve(import.meta.dirname, '..', file), 'utf8'))
-    expect(runtime.libraries.map((library: { name: string }) => library.name)).toEqual(['core', 'ui', 'lens'])
+    expect(runtime.libraries.map((library: { name: string }) => library.name)).toEqual(['core', 'ui', 'lens', 'kowalski'])
     expect(runtime.libraries[1]).toEqual({
       name: 'ui',
       dependencies: ['core'],

package/node_modules/@flickfyi/core/tsconfig.vite-dts.json

@@ -14,7 +14,8 @@
     "**/*.typecheck.*",
     "**/*.stories.tsx",
     "src/storybook",
-    "src/themes/stories"
+    "src/themes/stories",
+    "src/kowalski/stories"
   ],
   "compilerOptions": {
     "paths": {