@flickfyi/flkr 0.0.182 → 0.0.185

package/node_modules/@flickfyi/core/src/kowalski/catalog.ts

@@ -1,787 +1,193 @@
-import isURL from 'validator/lib/isURL.js'
-import { z } from 'zod/v4'
-
-/** A feature's store name; without one it is Kowalski<ExportName>. */
-export const kowalskiFeatureId = z
-	.string()
-	.regex(/^[A-Za-z][A-Za-z0-9]*$/)
-	.optional()
-export const kowalskiScope = z.enum(['private', 'public']).default('private')
-
-/** Per-item store fields are `<prefix><item id>`; Florge checks their keys from this map. */
-export const entryPrefixes = {
-	budget: 'spent_',
-	checklist: 'completed_',
-	habit: 'completed_',
-	poll: 'vote_',
-	recipe: 'step_',
-	scoreboard: 'score_',
-	shoppingList: 'got_',
-	taskBoard: 'status_',
-} as const
-
-/** In JavaScript `Date#getUTCDay` order, so index 0 is Sunday. */
-export const weekdayNames = [
-	'sunday',
-	'monday',
-	'tuesday',
-	'wednesday',
-	'thursday',
-	'friday',
-	'saturday',
-] as const
-
-/** Pure contracts shared by Core, Florge, and the catalog; no rendering imports. */
+import { BillSplitProps } from '~/kowalski/components/bill-split'
+import { BookmarkProps } from '~/kowalski/components/bookmark'
+import { BudgetProps } from '~/kowalski/components/budget'
+import { CalculatorProps } from '~/kowalski/components/calculator'
+import { ChecklistProps } from '~/kowalski/components/checklist'
+import { ColorPaletteProps } from '~/kowalski/components/color-palette'
+import { ContactProps } from '~/kowalski/components/contact'
+import { CountdownProps } from '~/kowalski/components/countdown'
+import { EventProps } from '~/kowalski/components/event'
+import { ExpenseProps } from '~/kowalski/components/expense'
+import { GoalProps } from '~/kowalski/components/goal'
+import { HabitProps } from '~/kowalski/components/habit'
+import { LedgerProps } from '~/kowalski/components/ledger'
+import { NoteProps } from '~/kowalski/components/note'
+import { PollProps } from '~/kowalski/components/poll'
+import { RandomPickerProps } from '~/kowalski/components/random-picker'
+import { RatingProps } from '~/kowalski/components/rating'
+import { ReminderProps } from '~/kowalski/components/reminder'
+import { RotationProps } from '~/kowalski/components/rotation'
+import { ScoreboardProps } from '~/kowalski/components/scoreboard'
+import { ShoppingListProps } from '~/kowalski/components/shopping-list'
+import { TaskBoardProps } from '~/kowalski/components/task-board'
+import { TimeZoneProps } from '~/kowalski/components/time-zone'
+import { TimerProps } from '~/kowalski/components/timer'
+import { TripProps } from '~/kowalski/components/trip'
+import { UnitConverterProps } from '~/kowalski/components/unit-converter'
+
+import { FortuneProps } from './fortune'
+import { LessonProps } from './lesson'
+import { RecipeProps } from './recipe'
+import { TimeSinceProps } from './time-since'
+
+export { unitDefinitions } from './calculations'
+export {
+	type KowalskiComponent,
+	kowalskiComponentSchema,
+	kowalskiFeatureId,
+	kowalskiScope,
+} from './feature-schema'
+export { FortuneData } from './fortune'
+export { LessonData } from './lesson'
+export { RecipeData } from './recipe'
+export { TimeSinceData } from './time-since'
+export { BillSplitData } from '~/kowalski/components/bill-split'
+export { BookmarkData, webAddressOptions } from '~/kowalski/components/bookmark'
+export { BudgetData } from '~/kowalski/components/budget'
+export { CalculatorData } from '~/kowalski/components/calculator'
+export { ChecklistData } from '~/kowalski/components/checklist'
+export { ColorPaletteData } from '~/kowalski/components/color-palette'
+export { ContactData } from '~/kowalski/components/contact'
+export { CountdownData } from '~/kowalski/components/countdown'
+export { EventData } from '~/kowalski/components/event'
+export { ExpenseData } from '~/kowalski/components/expense'
+export { GoalData } from '~/kowalski/components/goal'
+export { HabitData } from '~/kowalski/components/habit'
+export { LedgerData } from '~/kowalski/components/ledger'
+export { NoteData } from '~/kowalski/components/note'
+export { PollData, pollVoterSchema } from '~/kowalski/components/poll'
+export { RandomPickerData } from '~/kowalski/components/random-picker'
+export { RatingData } from '~/kowalski/components/rating'
+export { ReminderData } from '~/kowalski/components/reminder'
+export { RotationData } from '~/kowalski/components/rotation'
+export { ScoreboardData } from '~/kowalski/components/scoreboard'
+export { ShoppingListData } from '~/kowalski/components/shopping-list'
+export { TaskBoardData } from '~/kowalski/components/task-board'
+export { TimeZoneData } from '~/kowalski/components/time-zone'
+export { TimerData } from '~/kowalski/components/timer'
+export { TripData } from '~/kowalski/components/trip'
+export { UnitConverterData } from '~/kowalski/components/unit-converter'
+
+/** Contracts shared by Core, Florge, and the catalog. */
 export const kowalskiCatalog = {
 	billSplit: {
-		description:
-			'Split a bill equally with an optional tip, rounding in the selected currency.',
 		exportName: 'BillSplit',
-		props: featureProps({
-			currency: currency(),
-			people: z.number().int().min(1).max(1000),
-			tipPercent: z.number().min(0).max(100).default(0),
-			title: title('Split the bill'),
-			total: z.number().min(0).max(1e12),
-		}),
-		storeSchema: store({
-			people: z.number().int().min(1).max(1000).default(1),
-			tipPercent: z.number().min(0).max(100).default(0),
-			total: z.number().min(0).max(1e12).default(0),
-		}),
+		props: BillSplitProps,
 	},
 	bookmark: {
-		description: 'Display, edit, and retain a web bookmark. No implicit metadata fetch.',
 		exportName: 'Bookmark',
-		props: featureProps({
-			note: z.string().max(10_000).default(''),
-			title: title(),
-			url: webAddress(),
-		}),
-		storeSchema: store({
-			note: replacement(z.string().max(10_000).default('')),
-			title: replacement(z.string().max(160).default('')),
-			url: replacement(webAddress().nullable().default(null)),
-		}),
+		props: BookmarkProps,
 	},
 	budget: {
-		description:
-			'Track spending against category limits for one budget period. No bank connection or payments.',
 		exportName: 'Budget',
-		props: featureProps({
-			categories: identifiedList(
-				{ label: z.string().min(1).max(80), limit: z.number().positive().max(1e12) },
-				12
-			),
-			currency: currency(),
-			title: title('Budget'),
-		}),
-		storeSchema: entries(entryPrefixes.budget, z.number().min(0).max(1e12), {}),
+		props: BudgetProps,
 	},
 	calculator: {
-		description:
-			'A persistent keypad calculator with chained arithmetic, decimals, sign, percent, and repeated equals. Supports +, -, *, /. No executable expression strings.',
 		exportName: 'Calculator',
-		props: featureProps({
-			left: z.number().default(0),
-			operator: z.enum(['+', '-', '*', '/']).default('+'),
-			right: z.number().default(0),
-			title: title('Calculate'),
-		}),
-		storeSchema: store({
-			calculation: z
-				.object({
-					entry: z
-						.string()
-						.max(40)
-						.regex(/^(?:-?\d+(?:\.\d*)?(?:e[+-]?\d+)?|Error)$/),
-					left: z.number(),
-					operator: z.enum(['+', '-', '*', '/']),
-					overwrite: z.boolean(),
-					phase: z.enum(['left', 'operator', 'right', 'result', 'error']),
-					right: z.number(),
-				})
-				.refine(
-					calculation =>
-						calculation.phase === 'error'
-							? calculation.entry === 'Error'
-							: calculation.entry !== 'Error' &&
-								Number.isFinite(Number(calculation.entry)),
-					'Calculator entry must match its phase and represent a finite number.'
-				)
-				.default({
-					entry: '0',
-					left: 0,
-					operator: '+',
-					overwrite: false,
-					phase: 'left',
-					right: 0,
-				}),
-		}),
+		props: CalculatorProps,
 	},
 	checklist: {
-		description:
-			'A persistent checklist with independent completion and progress. No external actions.',
 		exportName: 'Checklist',
-		props: featureProps({
-			items: identifiedList({ label: z.string().min(1).max(500) }, 100),
-			title: title(),
-		}),
-		storeSchema: entries(entryPrefixes.checklist, z.boolean(), {}),
+		props: ChecklistProps,
 	},
 	colorPalette: {
-		description: 'Choose and retain an sRGB color and display matching shades.',
 		exportName: 'ColorPalette',
-		props: featureProps({
-			color: z.string().regex(/^#[\da-fA-F]{6}$/),
-			title: title('Palette'),
-		}),
-		storeSchema: store({
-			color: replacement(
-				z
-					.string()
-					.regex(/^#[\da-fA-F]{6}$/)
-					.default('#6366f1')
-			),
-		}),
+		props: ColorPaletteProps,
 	},
 	contact: {
-		description:
-			'Display, edit, and retain a contact. Does not insert into the address book.',
 		exportName: 'Contact',
-		props: featureProps({
-			email: z.email().optional(),
-			name: z.string().min(1).max(160),
-			phone: z.string().min(1).max(80).optional(),
-		}),
-		storeSchema: store({
-			email: replacement(z.email().nullable().default(null)),
-			name: replacement(z.string().max(160).default('')),
-			phone: replacement(z.string().min(1).max(80).nullable().default(null)),
-		}),
+		props: ContactProps,
 	},
 	countdown: {
-		description:
-			'Count down to an explicit instant. Resolve missing dates before instantiation.',
 		exportName: 'Countdown',
-		props: featureProps({
-			target: z.iso.datetime({ offset: true }),
-			timeZone: timeZone().default('UTC'),
-			title: title(),
-		}),
-		storeSchema: store({
-			target: replacement(z.iso.datetime({ offset: true }).nullable().default(null)),
-		}),
+		props: CountdownProps,
 	},
 	event: {
-		description:
-			'Save and edit event details in the app. Does not create a calendar event.',
 		exportName: 'Event',
-		props: featureProps({
-			location: z.string().max(500).default(''),
-			startsAt: z.iso.datetime({ offset: true }).nullable().default(null),
-			timeZone: timeZone().default('UTC'),
-			title: title(),
-		}),
-		storeSchema: store({
-			location: replacement(z.string().max(500).default('')),
-			startsAt: replacement(z.iso.datetime({ offset: true }).nullable().default(null)),
-			title: replacement(z.string().max(160).default('')),
-		}),
+		props: EventProps,
 	},
 	expense: {
-		description:
-			'Edit and retain one expense. No payments, bank connection, or exchange-rate lookup.',
 		exportName: 'Expense',
-		props: featureProps({
-			amount: z.number().min(0).max(1e12),
-			category: z.string().max(80).default('Other'),
-			currency: currency(),
-			title: title(),
-		}),
-		storeSchema: store({
-			amount: z.number().min(0).max(1e12).default(0),
-			category: replacement(z.string().max(80).default('Other')),
-			title: replacement(z.string().max(160).default('')),
-		}),
+		props: ExpenseProps,
+	},
+	fortune: {
+		exportName: 'Fortune',
+		props: FortuneProps,
 	},
 	goal: {
-		description:
-			'A personal goal with editable progress, target, and a fixed increment. Not a distributed counter.',
 		exportName: 'Goal',
-		props: featureProps({
-			progress: z.number().min(0).max(1e12).default(0),
-			step: z.number().positive().max(1e9).default(1),
-			target: z.number().positive().max(1e12),
-			title: title(),
-			unit: z.string().max(40).default(''),
-		}),
-		storeSchema: store({ progress: z.number().min(0).default(0) }),
+		props: GoalProps,
 	},
 	habit: {
-		description:
-			'Track a habit by local date and edit its weekday schedule. No notifications.',
 		exportName: 'Habit',
-		props: featureProps({
-			timeZone: timeZone().default('UTC'),
-			title: title(),
-			weekdays: weekdays(),
-		}),
-		storeSchema: entries(entryPrefixes.habit, z.boolean(), { weekdays: weekdays() }),
+		props: HabitProps,
 	},
 	ledger: {
-		description:
-			'A running tab of shared costs between two people, split evenly, with settle up. No payments.',
 		exportName: 'Ledger',
-		props: featureProps({
-			currency: currency(),
-			people: identifiedList({ label: z.string().min(1).max(80) }, 2, 2),
-			title: title('Shared tab'),
-		}),
-		storeSchema: store({
-			entries: z
-				.array(
-					z.strictObject({
-						amount: z.number().positive().max(1e12),
-						id: itemId(),
-						label: z.string().max(160),
-						paidBy: itemId(),
-					})
-				)
-				.max(200)
-				.default([]),
-		}),
+		props: LedgerProps,
+	},
+	lesson: {
+		exportName: 'Lesson',
+		props: LessonProps,
 	},
 	note: {
-		description: 'An editable persistent note. Plain text; no HTML or code execution.',
 		exportName: 'Note',
-		props: featureProps({
-			body: z.string().max(20_000),
-			title: z.string().max(160),
-		}),
-		storeSchema: store({
-			body: replacement(z.string().max(20_000).default('')),
-			title: replacement(z.string().max(160).default('')),
-		}),
+		props: NoteProps,
 	},
 	poll: {
 		exportName: 'Poll',
-		description:
-			'Cast or change a vote and derive totals from votes. Shared voting only when explicitly requested.',
-		props: featureProps({
-			options: identifiedList({ label: z.string().min(1).max(160) }, 12, 2),
-			question: z.string().min(1).max(500),
-			shared: z.boolean().default(false),
-		}),
-		// Each vote_<voter> holds an option id.
-		storeSchema: entries(entryPrefixes.poll, itemId(), {}),
+		props: PollProps,
 	},
 	randomPicker: {
-		description:
-			'Flip a coin, roll a die, or pick from a bounded integer range or list. Retains the last result.',
 		exportName: 'RandomPicker',
-		props: z.discriminatedUnion('mode', [
-			featureProps({ mode: z.literal('coin'), title: title('Pick one') }),
-			featureProps({ mode: z.literal('dice'), title: title('Pick one') }),
-			featureProps({
-				maximum: z.number().int().min(-1e9).max(1e9),
-				minimum: z.number().int().min(-1e9).max(1e9),
-				mode: z.literal('range'),
-				title: title('Pick one'),
-			}).refine(value => value.minimum <= value.maximum, {
-				message: 'Minimum cannot exceed maximum.',
-				path: ['maximum'],
-			}),
-			featureProps({
-				mode: z.literal('list'),
-				options: z.array(z.string().min(1).max(160)).min(1).max(100),
-				title: title('Pick one'),
-			}),
-		]),
-		// The last pick, with the choices it was drawn from so a changed picker drops it.
-		storeSchema: store({
-			result: z
-				.strictObject({
-					domain: pickerDomain(),
-					value: z.union([z.number().int(), z.string().max(160)]),
-				})
-				.nullable()
-				.default(null),
-		}),
+		props: RandomPickerProps,
 	},
 	rating: {
-		description: 'Rate one thing from one to five stars and keep a short note about it.',
 		exportName: 'Rating',
-		props: featureProps({
-			subject: z.string().min(1).max(160),
-			title: title('Your rating'),
-		}),
-		storeSchema: store({
-			note: replacement(z.string().max(2000).default('')),
-			stars: z.number().int().min(0).max(5).default(0),
-		}),
+		props: RatingProps,
 	},
 	recipe: {
-		description:
-			'Cook a recipe whose steps follow the Recipe Graph Format (rgf/0-draft): each step uses ingredients or earlier step outputs, waits on the steps in after, and may carry a duration, doneness cue, and attention. Ingredients carry a numeric amount and unit, and meta.servings is a number, so amounts scale with servings. Shows running timers, the current step, and the next few. No nutrition or shopping lookup.',
 		exportName: 'Recipe',
-		props: featureProps({
-			ingredients: identifiedList(
-				{
-					amount: z.number().positive().max(1e6).optional(),
-					label: z.string().min(1).max(160),
-					notes: z.array(z.string().max(160)).max(10).optional(),
-					unit: z.string().max(40).optional(),
-				},
-				60
-			),
-			servings: z.number().int().min(1).max(100).optional(),
-			// Steps follow RGF (rgf/0-draft): uses, outputs, and after form the dependency graph.
-			steps: z
-				.array(
-					z.strictObject({
-						after: z.array(itemId()).max(60).optional(),
-						attention: z.enum(['active', 'passive']).optional(),
-						doneness: z.string().max(200).optional(),
-						duration: z
-							.strictObject({
-								maxMinutes: z.number().nonnegative().max(10_080).optional(),
-								minMinutes: z.number().nonnegative().max(10_080).optional(),
-								raw: z.string().min(1).max(80),
-							})
-							.refine(
-								duration =>
-									duration.minMinutes === undefined ||
-									duration.maxMinutes === undefined ||
-									duration.minMinutes <= duration.maxMinutes,
-								'minMinutes cannot exceed maxMinutes.'
-							)
-							.optional(),
-						equipment: z.array(z.string().min(1).max(160)).max(20).optional(),
-						id: itemId(),
-						instruction: z.string().min(1).max(500),
-						kind: z.enum(['setup', 'transform', 'wait', 'serve']).optional(),
-						label: z.string().max(80).optional(),
-						outputs: z
-							.array(z.strictObject({ id: itemId(), name: z.string().max(160).optional() }))
-							.max(10)
-							.optional(),
-						temperature: z.string().min(1).max(80).optional(),
-						uses: z
-							.array(
-								z.strictObject({
-									id: itemId(),
-									portion: z.string().max(80).optional(),
-									source: z.discriminatedUnion('kind', [
-										z.strictObject({ ingredientId: itemId(), kind: z.literal('ingredient') }),
-										z.strictObject({ kind: z.literal('output'), outputId: itemId() }),
-									]),
-								})
-							)
-							.max(30)
-							.default([]),
-					})
-				)
-				.min(1)
-				.max(60),
-			title: title(),
-			yield: z.string().max(160).optional(),
-		}).superRefine((recipe, context) => {
-			// Every edge points at an earlier step, so the graph is acyclic.
-			const ingredients = new Set(recipe.ingredients.map(ingredient => ingredient.id))
-			const steps = new Set<string>()
-			const outputs = new Set<string>()
-			for (const step of recipe.steps) {
-				const valid =
-					!steps.has(step.id) &&
-					(step.after ?? []).every(id => steps.has(id)) &&
-					step.uses.every(use =>
-						use.source.kind === 'ingredient'
-							? ingredients.has(use.source.ingredientId)
-							: outputs.has(use.source.outputId)
-					)
-				if (!valid) {
-					context.addIssue({
-						code: 'custom',
-						message: `Step ${step.id} needs a unique ID and can only use ingredients and earlier steps.`,
-					})
-				}
-				steps.add(step.id)
-				for (const output of step.outputs ?? []) {
-					if (outputs.has(output.id)) {
-						context.addIssue({ code: 'custom', message: 'Output IDs must be unique.' })
-					}
-					outputs.add(output.id)
-				}
-			}
-		}),
-		// Each step_<id> holds whether the step is done and when its timer ends.
-		storeSchema: entries(
-			entryPrefixes.recipe,
-			z.strictObject({ done: z.boolean(), endsAt: z.number().nullable() }),
-			{
-				cooking: z.boolean().default(false),
-				servings: z.number().int().min(1).max(100).default(1),
-			}
-		),
+		props: RecipeProps,
 	},
 	reminder: {
-		description:
-			'Complete, reopen, and edit an in-app reminder. Does not schedule notifications.',
 		exportName: 'Reminder',
-		props: featureProps({
-			dueAt: z.iso.datetime({ offset: true }).nullable().default(null),
-			recurrence: z.enum(['none', 'daily', 'weekly']).default('none'),
-			timeZone: timeZone().optional(),
-			title: z.string().min(1).max(500),
-		}),
-		storeSchema: store({
-			completedAt: z.number().nullable().default(null),
-			dueAt: replacement(z.iso.datetime({ offset: true }).nullable().default(null)),
-			title: replacement(z.string().max(500).default('')),
-		}),
+		props: ReminderProps,
 	},
 	rotation: {
-		description:
-			'Take turns through a fixed group in order and pass the turn on when done.',
 		exportName: 'Rotation',
-		props: featureProps({
-			people: identifiedList({ label: z.string().min(1).max(80) }, 20, 2),
-			task: z.string().min(1).max(160),
-			title: title('Whose turn'),
-		}),
-		// The person whose turn it is; null means the first person.
-		storeSchema: store({
-			completed: z.number().int().min(0).default(0),
-			turn: itemId().nullable().default(null),
-		}),
+		props: RotationProps,
 	},
 	scoreboard: {
-		description:
-			'Keep score for a few players with a fixed step. Not a distributed counter or a league.',
 		exportName: 'Scoreboard',
-		props: featureProps({
-			players: identifiedList({ label: z.string().min(1).max(80) }, 12, 2),
-			step: z.number().int().positive().max(1000).default(1),
-			title: title('Scores'),
-		}),
-		storeSchema: entries(entryPrefixes.scoreboard, z.number().int(), {}),
+		props: ScoreboardProps,
 	},
 	shoppingList: {
-		description:
-			'Check items off a shopping list with optional prices and a running cart total. No ordering.',
 		exportName: 'ShoppingList',
-		props: featureProps({
-			currency: currency(),
-			items: identifiedList(
-				{
-					label: z.string().min(1).max(160),
-					price: z.number().min(0).max(1e9).optional(),
-					quantity: z.number().int().min(1).max(999).default(1),
-				},
-				100
-			),
-			title: title('Shopping list'),
-		}),
-		storeSchema: entries(entryPrefixes.shoppingList, z.boolean(), {}),
+		props: ShoppingListProps,
 	},
 	taskBoard: {
-		description:
-			'Move tasks between To do, Doing, and Done. No assignees, dates, or sync.',
 		exportName: 'TaskBoard',
-		props: featureProps({
-			tasks: identifiedList({ label: z.string().min(1).max(500) }, 50),
-			title: title('Tasks'),
-		}),
-		storeSchema: entries(entryPrefixes.taskBoard, z.enum(['todo', 'doing', 'done']), {}),
+		props: TaskBoardProps,
+	},
+	timeSince: {
+		exportName: 'TimeSince',
+		props: TimeSinceProps,
 	},
 	timeZone: {
-		description:
-			'Compare local times in named time zones, live or at an explicit instant.',
 		exportName: 'TimeZone',
-		props: featureProps({
-			at: z.iso.datetime({ offset: true }).nullable().default(null),
-			title: title('World clock'),
-			zones: z.array(timeZone()).min(2).max(6),
-		}),
-		storeSchema: store({
-			at: replacement(z.iso.datetime({ offset: true }).nullable().default(null)),
-		}),
+		props: TimeZoneProps,
 	},
 	timer: {
-		description:
-			'Countdown, focus, break, or stopwatch. Start, pause, resume, reset; no background alarm.',
 		exportName: 'Timer',
-		props: featureProps({
-			durationSeconds: z.number().int().min(1).max(604_800).default(300),
-			mode: z.enum(['countdown', 'focus', 'break', 'stopwatch']).default('countdown'),
-			title: title('Timer'),
-		}),
-		storeSchema: store({
-			elapsedSeconds: z.number().min(0).default(0),
-			startedAt: z.number().nullable().default(null),
-		}),
+		props: TimerProps,
 	},
 	trip: {
-		description: 'Edit and retain trip details. No bookings or itinerary retrieval.',
 		exportName: 'Trip',
-		props: featureProps({
-			destination: z.string().min(1).max(160),
-			endDate: z.iso.date().nullable().default(null),
-			origin: z.string().min(1).max(160),
-			startDate: z.iso.date().nullable().default(null),
-			title: title('Trip'),
-			transport: z.enum(['car', 'train', 'plane', 'walk', 'other']).default('other'),
-		}).refine(
-			value => !value.startDate || !value.endDate || value.endDate >= value.startDate,
-			{
-				message: 'The trip cannot end before it starts.',
-				path: ['endDate'],
-			}
-		),
-		storeSchema: store({
-			destination: replacement(z.string().max(160).default('')),
-			endDate: replacement(z.iso.date().nullable().default(null)),
-			origin: replacement(z.string().max(160).default('')),
-			startDate: replacement(z.iso.date().nullable().default(null)),
-		}).refine(
-			value =>
-				!value.startDate.value ||
-				!value.endDate.value ||
-				value.endDate.value >= value.startDate.value,
-			'The trip cannot end before it starts.'
-		),
+		props: TripProps,
 	},
 	unitConverter: {
-		description:
-			'Convert compatible length, mass, or temperature units deterministically.',
 		exportName: 'UnitConverter',
-		props: featureProps({
-			from: unit(),
-			title: title('Convert'),
-			to: unit(),
-			value: z.number(),
-		}).refine(
-			({ from, to }) => unitDefinitions[from].dimension === unitDefinitions[to].dimension,
-			{
-				message: 'Source and destination units must measure the same dimension.',
-				path: ['to'],
-			}
-		),
-		storeSchema: store({
-			from: replacement(unit().default('km')),
-			to: replacement(unit().default('mi')),
-			value: z.number().default(0),
-		}).refine(
-			({ from, to }) =>
-				unitDefinitions[from.value].dimension === unitDefinitions[to.value].dimension,
-			'Incompatible units.'
-		),
+		props: UnitConverterProps,
 	},
 }
-
-export type KowalskiComponent = keyof typeof kowalskiCatalog
-export const kowalskiComponentSchema = z.enum([
-	'checklist',
-	'timer',
-	'habit',
-	'goal',
-	'poll',
-	'event',
-	'reminder',
-	'trip',
-	'countdown',
-	'timeZone',
-	'colorPalette',
-	'billSplit',
-	'expense',
-	'unitConverter',
-	'calculator',
-	'randomPicker',
-	'contact',
-	'bookmark',
-	'note',
-	'budget',
-	'scoreboard',
-	'taskBoard',
-	'recipe',
-	'rotation',
-	'shoppingList',
-	'rating',
-	'ledger',
-])
-export type KowalskiInput<K extends KowalskiComponent> = z.input<
-	(typeof kowalskiCatalog)[K]['props']
->
-export type KowalskiProps<K extends KowalskiComponent> = z.output<
-	(typeof kowalskiCatalog)[K]['props']
->
-export type KowalskiState<K extends KowalskiComponent> = z.output<
-	(typeof kowalskiCatalog)[K]['storeSchema']
->
-export type PickerDomain = NonNullable<KowalskiState<'randomPicker'>['result']>['domain']
-export type Weekday = (typeof weekdayNames)[number]
-
-export const pollVoterSchema = z.object({
-	configuration: z.string().default(''),
-	voter: z.string().min(1),
-})
-
-export const webAddressOptions = {
-	max_allowed_length: 2048,
-	protocols: ['http', 'https'],
-	require_host: true,
-	require_protocol: true,
-	require_tld: false,
-	require_valid_protocol: true,
-}
-
-/** SI relationships; temperature offsets are applied before scaling. */
-export const unitDefinitions = {
-	c: { dimension: 'temperature', factor: 1, offset: 0 },
-	f: { dimension: 'temperature', factor: 5 / 9, offset: -32 },
-	ft: { dimension: 'length', factor: 0.3048, offset: 0 },
-	g: { dimension: 'mass', factor: 0.001, offset: 0 },
-	k: { dimension: 'temperature', factor: 1, offset: -273.15 },
-	kg: { dimension: 'mass', factor: 1, offset: 0 },
-	km: { dimension: 'length', factor: 1000, offset: 0 },
-	lb: { dimension: 'mass', factor: 0.45359237, offset: 0 },
-	m: { dimension: 'length', factor: 1, offset: 0 },
-	mi: { dimension: 'length', factor: 1609.344, offset: 0 },
-}
-
-function featureProps<Shape extends z.ZodRawShape>(shape: Shape) {
-	return z.strictObject({
-		id: kowalskiFeatureId,
-		revision: z.number().int().min(0).default(0),
-		scope: kowalskiScope,
-		...shape,
-	})
-}
-
-function currency() {
-	return z
-		.string()
-		.regex(/^[A-Z]{3}$/)
-		.default('USD')
-}
-
-/**
- * Per-item state as top-level `<prefix><id>` fields, which Quantum patches independently.
- * The template-literal record types them by prefix, so they never collide with the named
- * fields; any other key is rejected.
- */
-function entries<
-	Prefix extends string,
-	Value extends z.ZodType,
-	Shape extends z.ZodRawShape,
->(prefix: Prefix, value: Value, shape: Shape) {
-	const named = store(shape)
-	const keys = new Set(Object.keys(named.shape))
-	return z
-		.intersection(named.loose(), z.looseRecord(z.templateLiteral([prefix, z.string()]), value))
-		.refine(
-			state => Object.keys(state).every(key => keys.has(key) || key.startsWith(prefix)),
-			`Item fields must start with ${prefix}.`
-		)
-}
-
-/** Items with required stable ids, which key their saved state. */
-function identifiedList<Shape extends z.ZodRawShape>(shape: Shape, max: number, min = 1) {
-	return z
-		.array(z.strictObject(shape).extend({ id: itemId() }))
-		.min(min)
-		.max(max)
-		.refine(uniqueIds, 'IDs must be unique.')
-}
-
-/** Free-form ids; they key Quantum state, so __proto__ is out. */
-function itemId() {
-	return z
-		.string()
-		.min(1)
-		.max(80)
-		.refine(id => id !== '__proto__')
-}
-
-/**
- * The choices a pick was drawn from. A plain union of strict variants (anyOf in JSON
- * Schema) stays representable in the generated Quantum store source; oneOf does not.
- */
-function pickerDomain() {
-	return z.union([
-		z.strictObject({ mode: z.literal('coin') }),
-		z.strictObject({ mode: z.literal('dice') }),
-		z.strictObject({
-			maximum: z.number().int(),
-			minimum: z.number().int(),
-			mode: z.literal('range'),
-		}),
-		z.strictObject({
-			mode: z.literal('list'),
-			options: z.array(z.string().max(160)).max(100),
-		}),
-	])
-}
-
-function store<Shape extends z.ZodRawShape>(shape: Shape) {
-	return z.object({
-		configuration: z.record(z.string(), z.unknown()).nullable().default(null),
-		configurationRevision: z.number().int().min(0).default(0),
-		...shape,
-	})
-}
-
-/** A feature heading: never empty. */
-function title(): z.ZodString
-function title(fallback: string): z.ZodDefault<z.ZodString>
-function title(fallback?: string) {
-	const schema = z.string().min(1).max(160)
-	return fallback === undefined ? schema : schema.default(fallback)
-}
-
-function uniqueIds(items: ReadonlyArray<object>) {
-	const ids = items.map(item => ('id' in item ? item.id : undefined))
-	return new Set(ids).size === ids.length
-}
-
-function unit() {
-	return z.enum(['m', 'km', 'mi', 'ft', 'kg', 'g', 'lb', 'c', 'f', 'k'])
-}
-
-function timeZone() {
-	return z
-		.string()
-		.max(80)
-		.refine(value => {
-			try {
-				new Intl.DateTimeFormat('en', { timeZone: value }).format(0)
-				return true
-			} catch {
-				return false
-			}
-		}, 'Use a valid IANA time zone.')
-}
-
-/** Scheduled days of the week, by name. */
-function weekdays() {
-	return z
-		.array(z.enum(weekdayNames))
-		.max(7)
-		.default([...weekdayNames])
-}
-
-function webAddress() {
-	return z
-		.string()
-		.max(2048)
-		.refine(
-			value => isURL(value, webAddressOptions),
-			'Use a valid HTTP or HTTPS address.'
-		)
-}
-
-/** Catalog fields are whole-value replacements, not collaborative text insertions. */
-function replacement<Schema extends z.ZodType>(schema: Schema) {
-	return z.object({ value: schema }).default(() => ({ value: schema.parse(undefined) }))
-}