@poodle64/ui 2026.8.11 → 2026.8.13

package/dist/components/ui/document-detail/document-detail.svelte.d.ts

@@ -0,0 +1,34 @@
+/**
+     * DocumentDetail — one document's surface: its identity fields, recorded
+     * locations, tags, and collection memberships.
+     *
+     * Fixed props over plain data (#30). Sections render only when their data
+     * is present, so a consumer whose documents carry no locations never shows
+     * an empty heading. App-specific work — retract/re-extract buttons, an
+     * operations history — comes in through `actions` (the panel's footer) and
+     * `children` (sections after the panel); membership links are the app's
+     * own routed links via `collectionHref`, because this package has no
+     * router.
+     */
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+import { type WithElementRef } from '../../../utils.js';
+import type { LibraryDocumentDetail, LibraryMembership } from '../library-browse/types.js';
+type $$ComponentProps = WithElementRef<HTMLAttributes<HTMLDivElement>> & {
+    document: LibraryDocumentDetail | null;
+    loading?: boolean;
+    error?: string | null;
+    notFoundTitle?: string;
+    notFoundDescription?: string;
+    /** The app's own routed link per membership. */
+    collectionHref?: (membership: LibraryMembership) => string;
+    onOpenCollection?: (membership: LibraryMembership) => void;
+    onRetry?: () => void;
+    /** App-specific controls, rendered in the panel's footer. */
+    actions?: Snippet;
+    /** App-specific sections rendered after the panel. */
+    children?: Snippet;
+};
+declare const DocumentDetail: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type DocumentDetail = ReturnType<typeof DocumentDetail>;
+export default DocumentDetail;

package/dist/components/ui/document-detail/index.d.ts

@@ -0,0 +1,3 @@
+export { default as DocumentDetail } from './document-detail.svelte';
+export { default } from './document-detail.svelte';
+export type { LibraryBadge, LibraryDocumentDetail, LibraryField, LibraryLocation, LibraryMembership } from '../library-browse/types.js';

package/dist/components/ui/document-detail/index.js

@@ -0,0 +1,2 @@
+export { default as DocumentDetail } from './document-detail.svelte';
+export { default } from './document-detail.svelte';

package/dist/components/ui/library-browse/document-table.svelte

@@ -0,0 +1,101 @@
+<script lang="ts">
+	// The one catalogue table, shared by LibraryBrowse and CollectionDetail so
+	// the two surfaces cannot drift apart. Columns come and go with the data —
+	// a consumer that passes no `collections` never sees an empty column —
+	// which is what lets one table serve both the whole-catalogue view and a
+	// single collection's slice.
+	import {
+		Table as TableRoot,
+		TableBody,
+		TableCell,
+		TableHead,
+		TableHeader,
+		TableRow
+	} from '../table/index.js';
+	import StatusBadge from '../status-badge/status-badge.svelte';
+	import type { LibraryDocument } from './types.js';
+
+	let {
+		documents,
+		documentHref,
+		onOpen
+	}: {
+		documents: LibraryDocument[];
+		/** The app's own routed link per row; this package has no router of its own. */
+		documentHref?: (doc: LibraryDocument) => string;
+		onOpen?: (doc: LibraryDocument) => void;
+	} = $props();
+
+	const hasTags = $derived(documents.some((d) => d.tags?.length));
+	const hasCollections = $derived(documents.some((d) => d.collections?.length));
+	const hasBadges = $derived(documents.some((d) => d.badges?.length));
+</script>
+
+<div class="rounded-md border">
+	<TableRoot>
+		<TableHeader>
+			<TableRow>
+				<TableHead>Title</TableHead>
+				{#if hasTags}
+					<TableHead class="w-40">Tags</TableHead>
+				{/if}
+				{#if hasCollections}
+					<TableHead class="w-40">Collections</TableHead>
+				{/if}
+				{#if hasBadges}
+					<TableHead class="w-40 text-center">Status</TableHead>
+				{/if}
+			</TableRow>
+		</TableHeader>
+		<TableBody>
+			{#each documents as doc (doc.id)}
+				<TableRow>
+					<TableCell>
+						{#if documentHref}
+							<a
+								href={documentHref(doc)}
+								class="font-medium hover:underline"
+								onclick={() => onOpen?.(doc)}
+							>
+								{doc.title}
+							</a>
+						{:else if onOpen}
+							<button
+								type="button"
+								class="text-left font-medium hover:underline"
+								onclick={() => onOpen(doc)}
+							>
+								{doc.title}
+							</button>
+						{:else}
+							<span class="font-medium">{doc.title}</span>
+						{/if}
+					</TableCell>
+					{#if hasTags}
+						<TableCell class="text-muted-foreground text-xs">
+							{doc.tags?.join(', ') || '—'}
+						</TableCell>
+					{/if}
+					{#if hasCollections}
+						<TableCell class="text-muted-foreground text-xs">
+							{doc.collections?.join(', ') || '—'}
+						</TableCell>
+					{/if}
+					{#if hasBadges}
+						<TableCell class="text-center">
+							<div class="flex flex-wrap justify-center gap-1">
+								<!-- Keyed by index: LibraryBadge carries no id, and two memberships
+								     can legitimately map to the same label+status. -->
+								{#each doc.badges ?? [] as badge, i (i)}
+									<StatusBadge status={badge.status} label={badge.label} />
+								{:else}
+									<span class="text-muted-foreground text-xs">—</span>
+								{/each}
+							</div>
+						</TableCell>
+					{/if}
+				</TableRow>
+			{/each}
+		</TableBody>
+	</TableRoot>
+</div>

package/dist/components/ui/library-browse/document-table.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { LibraryDocument } from './types.js';
+type $$ComponentProps = {
+    documents: LibraryDocument[];
+    /** The app's own routed link per row; this package has no router of its own. */
+    documentHref?: (doc: LibraryDocument) => string;
+    onOpen?: (doc: LibraryDocument) => void;
+};
+declare const DocumentTable: import("svelte").Component<$$ComponentProps, {}, "">;
+type DocumentTable = ReturnType<typeof DocumentTable>;
+export default DocumentTable;

package/dist/components/ui/library-browse/facet-rail.svelte

@@ -0,0 +1,62 @@
+<script lang="ts">
+	// The facet rail beside the catalogue. Selection state belongs to the page
+	// (the app re-queries its own backend on change); this only renders the
+	// dimensions it is given and hands the next selection back.
+	import type { LibraryFacet } from './types.js';
+
+	let {
+		facets,
+		onChange
+	}: {
+		facets: LibraryFacet[];
+		onChange?: (key: string, selected: string[]) => void;
+	} = $props();
+
+	function toggle(facet: LibraryFacet, value: string) {
+		const has = facet.selected.includes(value);
+		if (facet.multiple) {
+			onChange?.(
+				facet.key,
+				has ? facet.selected.filter((v) => v !== value) : [...facet.selected, value]
+			);
+		} else {
+			onChange?.(facet.key, has ? [] : [value]);
+		}
+	}
+</script>
+
+<div class="space-y-4">
+	{#each facets as facet (facet.key)}
+		<div>
+			<h3 class="text-muted-foreground text-2xs mb-1 font-semibold tracking-wide uppercase">
+				{facet.label}
+			</h3>
+			{#if facet.options.length === 0}
+				<p class="text-muted-foreground text-xs">Populates once the catalogue holds documents.</p>
+			{:else}
+				<ul class="space-y-0.5">
+					{#each facet.options as option (option.value)}
+						{@const active = facet.selected.includes(option.value)}
+						<li>
+							<button
+								type="button"
+								aria-pressed={active}
+								class="hover:bg-muted flex w-full items-center justify-between rounded px-1.5 py-1 text-left text-sm {active
+									? 'bg-muted font-medium'
+									: ''}"
+								onclick={() => toggle(facet, option.value)}
+							>
+								<span class="truncate">{option.label ?? option.value}</span>
+								{#if option.count !== undefined}
+									<span class="text-muted-foreground font-mono text-xs tabular-nums">
+										{option.count}
+									</span>
+								{/if}
+							</button>
+						</li>
+					{/each}
+				</ul>
+			{/if}
+		</div>
+	{/each}
+</div>

package/dist/components/ui/library-browse/facet-rail.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { LibraryFacet } from './types.js';
+type $$ComponentProps = {
+    facets: LibraryFacet[];
+    onChange?: (key: string, selected: string[]) => void;
+};
+declare const FacetRail: import("svelte").Component<$$ComponentProps, {}, "">;
+type FacetRail = ReturnType<typeof FacetRail>;
+export default FacetRail;

package/dist/components/ui/library-browse/index.d.ts

@@ -0,0 +1,3 @@
+export { default as LibraryBrowse } from './library-browse.svelte';
+export { default } from './library-browse.svelte';
+export type { LibraryBadge, LibraryDocument, LibraryFacet, LibraryFacetOption, LibraryField, LibraryLocation, LibraryMembership, LibraryDocumentDetail, LibraryCollection, LibrarySearchResult, SearchSnippetSegment } from './types.js';

package/dist/components/ui/library-browse/index.js

@@ -0,0 +1,2 @@
+export { default as LibraryBrowse } from './library-browse.svelte';
+export { default } from './library-browse.svelte';

package/dist/components/ui/library-browse/library-browse.svelte

@@ -0,0 +1,235 @@
+<script lang="ts">
+	/**
+	 * LibraryBrowse — the faceted catalogue index: search, facet rail, active
+	 * filter chips, the document table, and a pager.
+	 *
+	 * Fixed props over plain data, deliberately — library data is stable in
+	 * shape, so it gets a fixed component; configuration is the schema-driven
+	 * half and lives in <SchemaForm> (#30). The component fetches nothing and
+	 * routes nothing: the page owns the query, the facet selections and the
+	 * offset, re-queries its own backend on every callback, and supplies its
+	 * own routed link per row via `documentHref`.
+	 */
+	import type { Snippet } from 'svelte';
+	import type { HTMLAttributes } from 'svelte/elements';
+	import { cn, type WithElementRef } from '../../../utils.js';
+	import Search from '@lucide/svelte/icons/search';
+	import LibraryIcon from '@lucide/svelte/icons/library';
+	import X from '@lucide/svelte/icons/x';
+	import { Input } from '../input/index.js';
+	import Button from '../button/button.svelte';
+	import { Badge } from '../badge/index.js';
+	import EmptyState from '../empty-state/empty-state.svelte';
+	import ErrorState from '../error-state/error-state.svelte';
+	import LoadingState from '../loading-state/loading-state.svelte';
+	import DocumentTable from './document-table.svelte';
+	import FacetRail from './facet-rail.svelte';
+	import type { LibraryDocument, LibraryFacet } from './types.js';
+
+	let {
+		documents,
+		facets = [],
+		query = '',
+		total,
+		offset = 0,
+		limit = 25,
+		loading = false,
+		error = null,
+		searchPlaceholder = 'Search the catalogue…',
+		emptyTitle = 'The catalogue is empty',
+		emptyDescription,
+		onQueryChange,
+		onFacetChange,
+		onPageChange,
+		onRetry,
+		documentHref,
+		onOpenDocument,
+		toolbar,
+		ref = $bindable(null),
+		class: className,
+		...restProps
+	}: WithElementRef<HTMLAttributes<HTMLDivElement>> & {
+		documents: LibraryDocument[];
+		facets?: LibraryFacet[];
+		/** The current search term. The page owns it; typing fires `onQueryChange`. */
+		query?: string;
+		/** Total matches across all pages; defaults to the rows given. */
+		total?: number;
+		offset?: number;
+		limit?: number;
+		loading?: boolean;
+		error?: string | null;
+		searchPlaceholder?: string;
+		/** Copy for a catalogue that is genuinely empty (no filter active). */
+		emptyTitle?: string;
+		emptyDescription?: string;
+		onQueryChange?: (query: string) => void;
+		onFacetChange?: (key: string, selected: string[]) => void;
+		/** Called with the next offset when the pager is used. */
+		onPageChange?: (offset: number) => void;
+		onRetry?: () => void;
+		/** The app's own routed link per row; this package has no router. */
+		documentHref?: (doc: LibraryDocument) => string;
+		onOpenDocument?: (doc: LibraryDocument) => void;
+		/** Trailing controls beside the search field (e.g. a saved-search menu). */
+		toolbar?: Snippet;
+	} = $props();
+
+	interface Chip {
+		key: string;
+		label: string;
+		remove: () => void;
+	}
+
+	// Chips are derived, never state: the page owns query and selections, so a
+	// chip's removal is just the matching callback with the value taken out.
+	const chips = $derived.by((): Chip[] => {
+		const out: Chip[] = [];
+		if (query) out.push({ key: 'q', label: `“${query}”`, remove: () => onQueryChange?.('') });
+		for (const facet of facets) {
+			for (const value of facet.selected) {
+				out.push({
+					key: `${facet.key}:${value}`,
+					label: `${facet.label.toLowerCase()}: ${value}`,
+					remove: () =>
+						onFacetChange?.(
+							facet.key,
+							facet.selected.filter((v) => v !== value)
+						)
+				});
+			}
+		}
+		return out;
+	});
+	const filtered = $derived(chips.length > 0);
+
+	function clearAll() {
+		if (query) onQueryChange?.('');
+		for (const facet of facets) {
+			if (facet.selected.length) onFacetChange?.(facet.key, []);
+		}
+	}
+
+	const shownTotal = $derived(total ?? documents.length);
+	// Floored at 1 so a consumer's limit: 0 cannot put Infinity in the pager.
+	const pageSize = $derived(Math.max(1, limit));
+	const pageCount = $derived(Math.max(1, Math.ceil(shownTotal / pageSize)));
+	const page = $derived(Math.floor(offset / pageSize) + 1);
+</script>
+
+<div bind:this={ref} class={cn('flex flex-col gap-4', className)} {...restProps}>
+	<div class="flex flex-wrap items-center gap-2">
+		<form
+			class="relative w-full flex-none sm:w-80"
+			onsubmit={(e) => {
+				e.preventDefault();
+				onQueryChange?.(query);
+			}}
+		>
+			<Search
+				class="text-muted-foreground pointer-events-none absolute top-1/2 left-2.5 size-4 -translate-y-1/2"
+			/>
+			<Input
+				type="search"
+				value={query}
+				placeholder={searchPlaceholder}
+				class="pl-8"
+				oninput={(e) => onQueryChange?.((e.target as HTMLInputElement).value)}
+			/>
+		</form>
+		{#if toolbar}
+			<div class="flex items-center gap-2">{@render toolbar()}</div>
+		{/if}
+	</div>
+
+	{#if chips.length > 0}
+		<div class="flex flex-wrap items-center gap-2">
+			{#each chips as chip (chip.key)}
+				<Badge variant="secondary" class="gap-1">
+					{chip.label}
+					<button
+						type="button"
+						aria-label="Remove filter {chip.label}"
+						class="hover:opacity-70"
+						onclick={chip.remove}
+					>
+						<X class="size-3" />
+					</button>
+				</Badge>
+			{/each}
+			<Button variant="ghost" size="sm" onclick={clearAll}>Clear all</Button>
+		</div>
+	{/if}
+
+	<div
+		class={facets.length > 0 ? 'grid gap-6 md:grid-cols-[220px_minmax(0,1fr)]' : 'grid gap-6'}
+	>
+		{#if facets.length > 0}
+			<aside class="hidden md:block" aria-label="Filters">
+				<FacetRail {facets} onChange={onFacetChange} />
+			</aside>
+		{/if}
+
+		<!-- min-w-0: a grid item defaults to min-width:auto, so without it this
+		     column stretches to the table's intrinsic width and the table's own
+		     scroller never gets a bounded box — the excess lands on the shell's
+		     scroller instead (measured in the first consumer). minmax(0,1fr) on
+		     the track carries the same guarantee at the grid level. -->
+		<div class="flex min-w-0 flex-col gap-3">
+			{#if loading}
+				<LoadingState message="Loading the catalogue…" />
+			{:else if error}
+				<ErrorState message={error}>
+					{#snippet action()}
+						{#if onRetry}
+							<Button variant="outline" onclick={onRetry}>Retry</Button>
+						{/if}
+					{/snippet}
+				</ErrorState>
+			{:else if documents.length === 0}
+				{#if filtered}
+					<EmptyState
+						icon={LibraryIcon}
+						title="No documents match this search"
+						description="Try a different term, or clear the filters to see the whole catalogue."
+					>
+						{#snippet action()}
+							<Button variant="outline" onclick={clearAll}>Clear filters</Button>
+						{/snippet}
+					</EmptyState>
+				{:else}
+					<EmptyState icon={LibraryIcon} title={emptyTitle} description={emptyDescription} />
+				{/if}
+			{:else}
+				<DocumentTable {documents} {documentHref} onOpen={onOpenDocument} />
+
+				<div class="flex flex-wrap items-center justify-between gap-2">
+					<p class="text-muted-foreground text-xs">
+						{shownTotal} document{shownTotal === 1 ? '' : 's'}
+					</p>
+					{#if onPageChange && shownTotal > pageSize}
+						<div class="flex items-center gap-2">
+							<Button
+								variant="outline"
+								size="sm"
+								disabled={offset === 0}
+								onclick={() => onPageChange(Math.max(0, offset - pageSize))}
+							>
+								Previous
+							</Button>
+							<span class="text-muted-foreground text-xs">Page {page} of {pageCount}</span>
+							<Button
+								variant="outline"
+								size="sm"
+								disabled={offset + pageSize >= shownTotal}
+								onclick={() => onPageChange(offset + pageSize)}
+							>
+								Next
+							</Button>
+						</div>
+					{/if}
+				</div>
+			{/if}
+		</div>
+	</div>
+</div>

package/dist/components/ui/library-browse/library-browse.svelte.d.ts

@@ -0,0 +1,44 @@
+/**
+     * LibraryBrowse — the faceted catalogue index: search, facet rail, active
+     * filter chips, the document table, and a pager.
+     *
+     * Fixed props over plain data, deliberately — library data is stable in
+     * shape, so it gets a fixed component; configuration is the schema-driven
+     * half and lives in <SchemaForm> (#30). The component fetches nothing and
+     * routes nothing: the page owns the query, the facet selections and the
+     * offset, re-queries its own backend on every callback, and supplies its
+     * own routed link per row via `documentHref`.
+     */
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+import { type WithElementRef } from '../../../utils.js';
+import type { LibraryDocument, LibraryFacet } from './types.js';
+type $$ComponentProps = WithElementRef<HTMLAttributes<HTMLDivElement>> & {
+    documents: LibraryDocument[];
+    facets?: LibraryFacet[];
+    /** The current search term. The page owns it; typing fires `onQueryChange`. */
+    query?: string;
+    /** Total matches across all pages; defaults to the rows given. */
+    total?: number;
+    offset?: number;
+    limit?: number;
+    loading?: boolean;
+    error?: string | null;
+    searchPlaceholder?: string;
+    /** Copy for a catalogue that is genuinely empty (no filter active). */
+    emptyTitle?: string;
+    emptyDescription?: string;
+    onQueryChange?: (query: string) => void;
+    onFacetChange?: (key: string, selected: string[]) => void;
+    /** Called with the next offset when the pager is used. */
+    onPageChange?: (offset: number) => void;
+    onRetry?: () => void;
+    /** The app's own routed link per row; this package has no router. */
+    documentHref?: (doc: LibraryDocument) => string;
+    onOpenDocument?: (doc: LibraryDocument) => void;
+    /** Trailing controls beside the search field (e.g. a saved-search menu). */
+    toolbar?: Snippet;
+};
+declare const LibraryBrowse: import("svelte").Component<$$ComponentProps, {}, "ref">;
+type LibraryBrowse = ReturnType<typeof LibraryBrowse>;
+export default LibraryBrowse;

package/dist/components/ui/library-browse/types.d.ts

@@ -0,0 +1,101 @@
+import type { Status } from '../status/index.js';
+/**
+ * The shared library-data vocabulary — plain shapes a consuming app maps its
+ * own API responses into. This package holds no HTTP client, no endpoint
+ * string, and no knowledge of any backend or app; that is what lets the
+ * backend be replaced without touching a consumer, and it is not negotiable
+ * for convenience (#30). An app's own state vocabulary (whatever its wire
+ * format says) is mapped by the app onto the shared five-state `Status`
+ * before it arrives here, as a `LibraryBadge`.
+ */
+/** A consumer-mapped state chip: one of the five shared states plus the app's label. */
+export interface LibraryBadge {
+    status: Status;
+    label: string;
+}
+/** One catalogue row. */
+export interface LibraryDocument {
+    id: string;
+    title: string;
+    /** Free labels on the document. */
+    tags?: string[];
+    /** Names of the collections it belongs to. */
+    collections?: string[];
+    /** Consumer-mapped state chips (e.g. one per collection's index state). */
+    badges?: LibraryBadge[];
+}
+/** One choice inside a facet. */
+export interface LibraryFacetOption {
+    value: string;
+    /** Documents carrying it; omit to render no count. */
+    count?: number;
+    /** Display label when the wire value is not presentable; defaults to `value`. */
+    label?: string;
+}
+/** One facet dimension in the browse rail. The page owns the selection state. */
+export interface LibraryFacet {
+    /** Stable key handed back through `onFacetChange`. */
+    key: string;
+    label: string;
+    options: LibraryFacetOption[];
+    /** Currently selected wire values. */
+    selected: string[];
+    /** Allow several selections at once (default: a single toggle). */
+    multiple?: boolean;
+}
+/** A label→value row in a document's field list. */
+export interface LibraryField {
+    label: string;
+    value: string;
+    /** Render the value in the code/data face (a hash, a path, a machine value). */
+    mono?: boolean;
+}
+/** One recorded location of a document. */
+export interface LibraryLocation {
+    path: string;
+    primary?: boolean;
+    badge?: LibraryBadge;
+}
+/** One collection membership of a document. */
+export interface LibraryMembership {
+    id: string;
+    name: string;
+    badge?: LibraryBadge;
+}
+/** The full detail of one document. */
+export interface LibraryDocumentDetail {
+    id: string;
+    title: string;
+    fields?: LibraryField[];
+    tags?: string[];
+    locations?: LibraryLocation[];
+    memberships?: LibraryMembership[];
+}
+/** The identity of one collection. */
+export interface LibraryCollection {
+    id: string;
+    name: string;
+    /** One already-formatted meta line (owner · pipeline · state). */
+    subtitle?: string;
+    description?: string;
+    badge?: LibraryBadge;
+}
+/** A snippet segment; `highlight` marks the part that matched the query. */
+export interface SearchSnippetSegment {
+    text: string;
+    highlight?: boolean;
+}
+/** One ranked search hit. */
+export interface LibrarySearchResult {
+    id: string;
+    title: string;
+    /** The matched passage: plain text, or segments carrying highlights. */
+    snippet?: string | SearchSnippetSegment[];
+    /** Relevance in [0, 1]; rendered as a percentage. */
+    score?: number;
+    /** Where the hit came from — a collection or corpus name. */
+    source?: string;
+    badges?: LibraryBadge[];
+    /** One already-formatted trailing meta line (a date, a type). */
+    meta?: string;
+}

package/dist/components/ui/library-browse/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/ui/schema-form/context.d.ts

@@ -0,0 +1,31 @@
+import type { createAjv, JsonSchema } from '@jsonforms/core';
+/**
+ * The Ajv instance `@jsonforms/core` builds. Typed through its own factory so
+ * this package never names `ajv` — a transitive dependency of the engine, not
+ * a dependency of ours.
+ */
+export type FormAjv = ReturnType<typeof createAjv>;
+/**
+ * The form-wide facts every nested element needs, published once by
+ * `<SchemaForm>` rather than drilled through a recursive component tree.
+ * Everything reactive is exposed as a getter, so a context read stays live
+ * under Svelte 5's signals.
+ */
+export interface SchemaFormContext {
+    /** The root JSON Schema every scope resolves against. */
+    readonly schema: JsonSchema;
+    /** The whole current value; rules and every widget read from here. */
+    readonly data: Record<string, unknown>;
+    /** Whether the whole form is disabled. */
+    readonly disabled: boolean;
+    /** Prefix for generated element ids. */
+    readonly idPrefix: string;
+    /** Validation messages by dot path, from the schema itself. */
+    readonly errors: Record<string, string[]>;
+    /** The shared Ajv instance rule conditions are evaluated with. */
+    readonly ajv: FormAjv;
+    /** Commit one field. */
+    change: (path: string, value: unknown) => void;
+}
+export declare const setSchemaFormContext: (context: SchemaFormContext) => SchemaFormContext;
+export declare const getSchemaFormContext: () => SchemaFormContext;

package/dist/components/ui/schema-form/context.js

@@ -0,0 +1,10 @@
+import { getContext, setContext } from 'svelte';
+const KEY = Symbol('poodle64-schema-form');
+export const setSchemaFormContext = (context) => setContext(KEY, context);
+export const getSchemaFormContext = () => {
+    const context = getContext(KEY);
+    if (!context) {
+        throw new Error('@poodle64/ui: a schema-form part was rendered outside <SchemaForm>. Render the form, not its internals.');
+    }
+    return context;
+};