@flickfyi/flkr 0.0.141 → 0.0.153

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

@@ -0,0 +1,787 @@
+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. */
+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),
+		}),
+	},
+	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)),
+		}),
+	},
+	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), {}),
+	},
+	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,
+				}),
+		}),
+	},
+	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(), {}),
+	},
+	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')
+			),
+		}),
+	},
+	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)),
+		}),
+	},
+	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)),
+		}),
+	},
+	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('')),
+		}),
+	},
+	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('')),
+		}),
+	},
+	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) }),
+	},
+	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() }),
+	},
+	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([]),
+		}),
+	},
+	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('')),
+		}),
+	},
+	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(), {}),
+	},
+	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),
+		}),
+	},
+	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),
+		}),
+	},
+	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),
+			}
+		),
+	},
+	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('')),
+		}),
+	},
+	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),
+		}),
+	},
+	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(), {}),
+	},
+	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(), {}),
+	},
+	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']), {}),
+	},
+	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)),
+		}),
+	},
+	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),
+		}),
+	},
+	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.'
+		),
+	},
+	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.'
+		),
+	},
+}
+
+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) }))
+}