@quillmark/svelte 0.13.0 → 0.15.0

package/NOTICE

@@ -6,9 +6,10 @@ Copyright 2026 Nibs
 This package contains SVG glyph geometry derived from Lucide, carried in source
 rather than installed.
 
-`visual/icons/nodes.ts` holds sixteen verbatim from @lucide/svelte 1.28.0:
+`visual/icons/nodes.ts` holds nineteen verbatim from @lucide/svelte 1.28.0:
 chevron-right, arrow-right, chevron-down, chevron-up, bold, italic, underline,
-strikethrough, code, link, hash, info, plus, x, trash-2 and minus.
+strikethrough, code, link, hash, info, plus, x, trash-2, minus, check, calendar
+and calendar-check.
 
 `core/codec/table-view.ts` holds a plus and four text-alignment glyphs derived
 from an earlier release of the same project.

package/dist/core/codec/field.d.ts

@@ -71,16 +71,10 @@ export interface CreateFieldOpts {
      * a body's invitation. The initial value; {@link FieldController.setPlaceholder}
      * moves it after mount. Empty/absent shows no ghost. */
     placeholder?: string;
-    /** The placeholder is what the unset field prints, so it goes at the leaf's first
-     * edit: the edit answers the field, and emptied the leaf holds an empty answer, which
-     * prints empty. Absent, the placeholder is an invitation (a body's) and returns
-     * whenever the leaf is empty. */
+    /** The placeholder goes at the leaf's first edit: the edit answers the leaf, and
+     * emptied it holds an empty answer, which prints empty. Absent, the placeholder
+     * returns whenever the leaf is empty. */
     placeholderUntilEdit?: boolean;
-    /** Ghost text shown on the empty leaf until its first edit: an unset field's
-     * `example:`, at rest where there is no placeholder and in the placeholder's stead
-     * while the leaf holds the focus. The initial value; {@link FieldController.setExample}
-     * moves it after mount. */
-    example?: string;
     onFocus?(addr: Addr): void;
     /** Fired with the new USV caret after an edit or a selection move. */
     onCaretMove?(addr: Addr, pos: number): void;
@@ -118,9 +112,6 @@ export interface FieldController {
      * a transaction would fire `onCaretMove` at a moment the caret did not move.
      */
     setPlaceholder(text: string | undefined): void;
-    /** Move the example ghost after mount, the way {@link setPlaceholder} moves the
-     *  other one. */
-    setExample(text: string | undefined): void;
     /** Move the default an unset leaf holds after mount: a retype or a quill swap
      *  re-seats an unset leaf on the new kind's default, and leaves a written one be. */
     setFallback(content: Content | undefined): void;
@@ -220,7 +211,5 @@ export declare function proseLeafPlugins(schema: Schema, opts: {
     placeholder?: () => string | undefined;
     /** {@link CreateFieldOpts.placeholderUntilEdit}. */
     placeholderUntilEdit?: boolean;
-    /** The focused leaf's ghost, read live for the same reason. */
-    example?: () => string | undefined;
     afterHistory?: Plugin[];
 }): Plugin[];

package/dist/core/codec/field.js

@@ -146,10 +146,9 @@ export function createField(opts) {
     const reconciler = createReconciler(shown());
     let index; // rebuilt on every structural change
     let view;
-    // The ghosts' live cells: the ghost plugin reads them per pass, so moving one is
-    // an assignment plus a re-render rather than a rebuilt plugin stack.
+    // The ghost's live cell: the ghost plugin reads it per pass, so moving it is an
+    // assignment plus a re-render rather than a rebuilt plugin stack.
     let placeholderText = opts.placeholder;
-    let exampleText = opts.example;
     // The views nested inside this leaf: one per table cell (`table-view.ts`). The
     // leaf holds the set because chrome asks the leaf, not the island, which view
     // holds the caret: the format popover raises over a cell exactly as over the
@@ -269,7 +268,6 @@ export function createField(opts) {
                 // given one later; the plugin draws nothing while the text is empty.
                 placeholder: () => placeholderText,
                 placeholderUntilEdit: opts.placeholderUntilEdit,
-                example: () => exampleText,
                 afterHistory: [anchorPlugin(seededAnchors)]
             })
         });
@@ -418,12 +416,6 @@ export function createField(opts) {
             // transaction, so nothing commits and no caret is reported.
             view.setProps({});
         },
-        setExample(text) {
-            if (text === exampleText)
-                return;
-            exampleText = text;
-            view.setProps({});
-        },
         setFallback(content) {
             if (content === fallback || (content && fallback && contentEqual(content, fallback)))
                 return;
@@ -533,7 +525,7 @@ export function proseLeafPlugins(schema, opts) {
         list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin());
     if (schema === plainSchema)
         list.push(plainClipboardPlugin());
-    if (opts.placeholder || opts.example)
+    if (opts.placeholder)
         list.push(ghostPlugin(opts));
     return list;
 }
@@ -590,18 +582,16 @@ function pastAtomPlugin() {
     });
 }
 /**
- * The empty leaf's ghosts. A node decoration stamps the sole empty textblock with a
- * class and the ghost text, which `prose.css` draws from the attributes: so the text
+ * The empty leaf's ghost. A node decoration stamps the sole empty textblock with a
+ * class and the ghost text, which `prose.css` draws from the attribute: so the text
  * never enters the document, the caret path, or a `pmToContent` export, and it
  * vanishes the instant the leaf holds any content (the emptiness test fails).
  *
- * `data-placeholder` is drawn at rest, and `data-example` where there is none, and in
- * its stead while the view holds the focus. The example is stamped only until the
- * state's first edit, after which the leaf has been answered, and so is a placeholder
- * that says what the unset field prints (`placeholderUntilEdit`). An inline leaf's
- * ghost keeps to the one line the leaf is (`qm-prose-placeholder-line`).
+ * Under `placeholderUntilEdit` it is stamped only until the state's first edit, after
+ * which the leaf has been answered. An inline leaf's ghost keeps to the one line the
+ * leaf is (`qm-prose-placeholder-line`).
  *
- * The texts are read per decoration pass rather than closed over, so moving a ghost is
+ * The text is read per decoration pass rather than closed over, so moving the ghost is
  * a re-render and never a document edit.
  */
 function ghostPlugin(opts) {
@@ -616,8 +606,7 @@ function ghostPlugin(opts) {
             decorations(state) {
                 const edited = key.getState(state);
                 const text = edited && opts.placeholderUntilEdit ? undefined : opts.placeholder?.();
-                const example = edited ? undefined : opts.example?.();
-                if (!text && !example)
+                if (!text)
                     return null;
                 const { doc } = state;
                 const first = doc.firstChild;
@@ -629,10 +618,7 @@ function ghostPlugin(opts) {
                         ? 'qm-prose-placeholder qm-prose-placeholder-line'
                         : 'qm-prose-placeholder'
                 };
-                if (text)
-                    attrs['data-placeholder'] = text;
-                if (example)
-                    attrs['data-example'] = example;
+                attrs['data-placeholder'] = text;
                 return DecorationSet.create(doc, [Decoration.node(0, first.nodeSize, attrs)]);
             }
         }

package/dist/core/codec/prose.css

@@ -196,21 +196,19 @@ li.ProseMirror-selectednode::after {
 }
 
 /* The empty leaf's ghost (`field.ts`, `ghostPlugin`): a node decoration's data
-   attributes, so the text stays out of the document. At the rung every control's
+   attribute, so the text stays out of the document. At the rung every control's
    placeholder takes; the italic is what a leaf with no written neighbour has instead
    of the step to `ink`.
 
    After the empty line rather than before it, and pulled up one line box onto it: the
    caret keeps the start of that line, and a ghost's lines past the first grow the
    leaf rather than hang over what follows it. A block leaf's ghost wraps and keeps the
-   breaks it was written with, a `body.example` being a document's worth; an inline
-   leaf's keeps to the one line the leaf is. The example is drawn at rest where there
-   is no placeholder, and stands in for the placeholder while the leaf holds the focus.
+   breaks it was written with, a body `default:` being a document's worth; an inline
+   leaf's keeps to the one line the leaf is.
 
    Drawn only where there is text to draw: an empty box pulled up a line would take
    the empty line with it. */
-.ProseMirror .qm-prose-placeholder[data-placeholder]::after,
-.ProseMirror .qm-prose-placeholder[data-example]::after {
+.ProseMirror .qm-prose-placeholder[data-placeholder]::after {
 	content: attr(data-placeholder);
 	display: block;
 	margin-top: -1lh;
@@ -219,10 +217,6 @@ li.ProseMirror-selectednode::after {
 	font-style: italic;
 	pointer-events: none;
 }
-.ProseMirror .qm-prose-placeholder[data-example]:not([data-placeholder])::after,
-.ProseMirror-focused .qm-prose-placeholder[data-example]::after {
-	content: attr(data-example);
-}
 .ProseMirror .qm-prose-placeholder.qm-prose-placeholder-line::after {
 	white-space: nowrap;
 	overflow: hidden;

package/dist/core/theme.css

@@ -164,12 +164,12 @@
 	   stacked on one. */
 	--_qm-border-faint: color-mix(in oklab, var(--_qm-bg), var(--_qm-border) 50%);
 	/* Three rungs, and nothing under the last: a step below `label` lands under 3:1 on
-	   the well a field draws it against, and what would take it — an example, an unset
-	   value's word — is content a reader has to read (WCAG 1.4.3), not decoration.
+	   the well a field draws it against, and what would take it — an unset value's word,
+	   an invitation — is content a reader has to read (WCAG 1.4.3), not decoration.
 	   `ink` is written. `default` is the resolved `default:` drawn as the value it
 	   prints: near enough to `ink` to read as an answer, a step off it so it never
-	   reads as a written one. `label` is words about a value rather than the value — an
-	   `example:`, `None`, a format hint — and the chrome that names fields; in italic
+	   reads as a written one. `label` is words about a value rather than the value —
+	   `None`, a format hint, an invitation — and the chrome that names fields; in italic
 	   where it is a leaf's ghost, which has no written neighbour to be read against. */
 	--_qm-ink: var(--_qm-fg);
 	--_qm-ink-default: color-mix(in oklab, var(--_qm-fg), var(--_qm-bg) 20%);

package/dist/visual/Card.svelte

@@ -317,6 +317,7 @@
 						unframed
 						label={t.strings.bodyLabel}
 						placeholder={card.bodyGhost}
+						placeholderUntilEdit
 						leafKey={ops.leafKey(undefined)}
 						{onFocus}
 						{onCaretMove}

package/dist/visual/DateField.svelte

@@ -1,10 +1,17 @@
 <!--
  A `date` (or `datetime`) field → a styled segmented date field on bits-ui. The
- stored value is a string (fixture uses `YYYY-MM-DD`, blank to mean "today at
- render"); a cleared control commits `undefined` (the unset rung): the parent
- removes the field, so the memo quill's blank-date → `datetime.today`
- substitution applies. The value-object a date field lowers to is a
- render-time concern: the editor only sees the stored string.
+ stored value is a string, `YYYY-MM-DD` or `today`; a cleared control commits
+ `undefined` (the unset rung): the parent removes the field, and the quill's
+ `default:` applies. The value-object a date field lowers to is a render-time
+ concern: the editor only sees the stored string.
+
+ `today` is the render date rather than a written one (canon `SCHEMAS.md`), so its
+ digits take the default rung: they print, and nothing wrote them. The digits are
+ the local date, which is what `resolve` and a session opened without a date both
+ render. The Today toggle writes `today`, and pressed, writes those digits; `T` in a
+ segment writes `today` too. An edit to a segment writes a whole date, the other
+ segments the render date's. A `default: today` presses the toggle at the default
+ rung while the field is unset.
 
  Styled rather than a native `<input type="date">`: that control's calendar popup
  is UA-owned and reaches no dial. `DateField` (segments, no
@@ -41,14 +48,20 @@
 -->
 <script lang="ts">
 	import { DateField as BitsDateField } from 'bits-ui';
-	import { parseDate, type DateValue } from '@internationalized/date';
+	import { getLocalTimeZone, parseDate, today, type DateValue } from '@internationalized/date';
+	import Icon from './icons/Icon.svelte';
+	import { wording } from './strings.js';
 	import { syncedLocal } from './synced.svelte.js';
 	import './controls.css';
 
+	const t = wording();
+	const TODAY = 'today';
+	const renderDate = today(getLocalTimeZone());
+
 	interface Props {
 		value: string | undefined;
-		/** The resolved `default:` in the boundary's currency (`YYYY-MM-DD`): parsed
-		 * for display only, shown while unset, never written. */
+		/** The declared `default:` (`YYYY-MM-DD` or `today`): parsed for display only,
+		 * shown while unset, never written. */
 		fallback?: string;
 		/** Accessible name for a field nothing else names: an object property, whose
 		 * name is the field label plus the property's. A field's own date takes
@@ -65,9 +78,12 @@
 		labelledBy?: string;
 		/** The parked `description` (FieldLabel): announced after the name. */
 		describedBy?: string;
+		/** A `datetime`: `today` is no value of its type, so it draws no toggle and
+		 * takes no `T`. */
+		datetime?: boolean;
 		onCommit: (v: string | undefined) => void;
 	}
-	let { value, fallback, label, labelledBy, describedBy, onCommit }: Props = $props();
+	let { value, fallback, label, labelledBy, describedBy, datetime, onCommit }: Props = $props();
 
 	let wrapEl: HTMLElement | undefined = $state();
 	/** Take the caret: what the label click, and a parent placing focus here, calls.
@@ -83,6 +99,7 @@
 	// throws on a malformed authored value: an empty field is the honest render.
 	function toDateValue(s: string): DateValue | undefined {
 		if (!s) return undefined;
+		if (s === TODAY) return renderDate;
 		try {
 			return parseDate(s);
 		} catch {
@@ -110,6 +127,27 @@
 	// a boolean so the substitution below narrows on the one fact it needs.
 	const ghost = $derived(local.value === '' ? fallbackDate : undefined);
 	const seated = $derived(value == null && seat && local.value !== '');
+	/** Who put `today` here, while the field follows the render date. */
+	const follows = $derived(
+		local.value === TODAY ? 'authored' : value == null && fallback === TODAY ? 'default' : undefined
+	);
+
+	function write(next: string): void {
+		local.value = next;
+		seat = false;
+		onCommit(next);
+	}
+	function toggle(): void {
+		write(follows ? renderDate.toString() : TODAY);
+	}
+	function shortcut(e: KeyboardEvent): void {
+		if (datetime || e.key.toLowerCase() !== 't' || e.ctrlKey || e.metaKey || e.altKey) return;
+		const seg = (e.target as HTMLElement).dataset.segment;
+		if (!seg || seg === 'literal') return;
+		e.preventDefault();
+		e.stopPropagation();
+		write(TODAY);
+	}
 
 	/** Focus moving between segments is neither an entry nor a leaving. */
 	const within = (e: FocusEvent): boolean => !!wrapEl?.contains(e.relatedTarget as Node | null);
@@ -152,7 +190,13 @@
 	}
 </script>
 
-<span class="qm-date-wrap" bind:this={wrapEl} onfocusin={enter} onfocusout={leave}>
+<span
+	class="qm-date-wrap"
+	bind:this={wrapEl}
+	onfocusin={enter}
+	onfocusout={leave}
+	onkeydowncapture={shortcut}
+>
 	<BitsDateField.Root
 		value={parsed}
 		placeholder={fallbackDate}
@@ -160,9 +204,9 @@
 			// `CalendarDate.toString()` is exactly `YYYY-MM-DD`. A cleared or
 			// half-typed field yields undefined: the unset rung. The primitive reports
 			// its own value again as a segment loses focus, which is no edit, and over a
-			// seated default would write it.
+			// seated default or `today` would write it.
 			const next = d?.toString() ?? '';
-			if (next === local.value) return;
+			if (next === (parsed?.toString() ?? '')) return;
 			local.value = next;
 			if (!d) seat = false;
 			onCommit(d?.toString());
@@ -179,7 +223,7 @@
 			aria-labelledby={labelledBy}
 			aria-describedby={describedBy}
 			data-ghosted={ghost ? '' : undefined}
-			data-default={seated ? '' : undefined}
+			data-default={seated || follows ? '' : undefined}
 		>
 			{#snippet children({ segments })}
 				<!-- Keyed by index: `part` repeats (the `literal` separators between
@@ -194,6 +238,17 @@
 						{shown.text}
 					</BitsDateField.Segment>
 				{/each}
+				{#if !datetime}
+					<button
+						type="button"
+						class="qm-chip qm-tap-floor qm-focus-ring qm-date-today"
+						aria-pressed={!!follows}
+						data-default={follows === 'default' ? '' : undefined}
+						onclick={toggle}
+					>
+						<Icon name={follows ? 'calendar-check' : 'calendar'} />{t.strings.dateToday}
+					</button>
+				{/if}
 			{/snippet}
 		</BitsDateField.Input>
 	</BitsDateField.Root>
@@ -235,4 +290,32 @@
 	.qm-date-wrap :global(.qm-date[data-default] .qm-date-segment) {
 		color: var(--_qm-ink-default);
 	}
+	/* The toggle's state is its fill and its glyph, never the pointer: a hover fill
+	 would read as pressed. Off, it rests hidden where a pointer can reveal it, still
+	 holding its width so the digits never shift. It sits inside the box's line, so
+	 the box stands as tall as the inputs beside it. */
+	.qm-date-today {
+		margin-inline-start: auto;
+		padding-block: var(--_qm-space-half);
+		line-height: 1;
+		border-radius: var(--_qm-radius-inner);
+	}
+	.qm-date-today:hover {
+		background: transparent;
+		color: var(--_qm-ink-label);
+	}
+	.qm-date-today[aria-pressed='true'] {
+		background: var(--_qm-accent-tint);
+		color: var(--_qm-ink);
+	}
+	.qm-date-today[data-default] {
+		background: transparent;
+		box-shadow: inset 0 0 0 var(--_qm-border-width) var(--_qm-border);
+		color: var(--_qm-ink-default);
+	}
+	@media (hover: hover) {
+		.qm-date-wrap:not(:hover, :focus-within) .qm-date-today[aria-pressed='false'] {
+			opacity: 0;
+		}
+	}
 </style>

package/dist/visual/DateField.svelte.d.ts

@@ -1,8 +1,8 @@
 import './controls.css';
 interface Props {
     value: string | undefined;
-    /** The resolved `default:` in the boundary's currency (`YYYY-MM-DD`): parsed
-     * for display only, shown while unset, never written. */
+    /** The declared `default:` (`YYYY-MM-DD` or `today`): parsed for display only,
+     * shown while unset, never written. */
     fallback?: string;
     /** Accessible name for a field nothing else names: an object property, whose
      * name is the field label plus the property's. A field's own date takes
@@ -19,6 +19,9 @@ interface Props {
     labelledBy?: string;
     /** The parked `description` (FieldLabel): announced after the name. */
     describedBy?: string;
+    /** A `datetime`: `today` is no value of its type, so it draws no toggle and
+     * takes no `T`. */
+    datetime?: boolean;
     onCommit: (v: string | undefined) => void;
 }
 declare const DateField: import("svelte").Component<Props, {

package/dist/visual/Field.svelte

@@ -33,7 +33,6 @@
 		VARIANT_DISCRIMINANT,
 		arrayLayout,
 		baseType,
-		exampleGhost,
 		ghostDefault,
 		isContainer,
 		optionalCell,
@@ -115,25 +114,24 @@
 
 	// What an unset field shows of its `default:`: the resolved value (provenance,
 	// `source === 'default'`). `ghost` is the raw typed value (enum/number/boolean
-	// fallbacks, a content leaf's `Content`), `defaultStr` its string form (the date
-	// control's `YYYY-MM-DD`); an object-valued default has none. An array draws its
-	// declared literal instead, which is what a take writes (`ArrayField`).
+	// fallbacks, a content leaf's `Content`), `defaultStr` its string form; an
+	// object-valued default has none. An array draws its declared literal instead,
+	// which is what a take writes (`ArrayField`).
 	// A default that prints stands in the control as the value it is, at the default
 	// rung, and the first edit takes it (VISUAL_EDITOR §"The commitment ladder"). Where
-	// nothing prints, a control draws words: the `none` an optional cell prints, and
-	// a free-text field's `example:`.
+	// nothing prints, a control draws words: the `none` an optional cell prints.
 	const ghost = $derived(ghostDefault(provenance));
 	const defaultStr = $derived(
 		field.control === 'prose' ? titleText(ghost) || undefined : stringifyGhost(ghost)
 	);
 	const printed = $derived(printedText(defaultStr));
-	// A text or number control reads its default off the schema, not the resolved row:
-	// the row stops naming a default once the field is written, and emptying a written
-	// field still has to know that the default prints.
+	// A text, number or date control reads its default off the schema, not the resolved
+	// row: the row stops naming a default once the field is written, and emptying a
+	// written field still has to know that the default prints. A date's `default: today`
+	// resolves to digits, and the control has to know it follows the render date.
 	const declared = $derived(printedText(field.schema.default));
 	const optional = $derived(optionalCell(field.schema));
 	const none = $derived(optional && value == null ? t.strings.optionalGhost : undefined);
-	const example = $derived(value == null ? exampleGhost(field.schema) : undefined);
 	// A variant resolves as one rung whose value is the whole container, so the
 	// discriminant's ghost is that container's own discriminant cell.
 	const ghostMember = $derived(
@@ -287,7 +285,6 @@
 					fallback={printed ? (ghost as Content) : undefined}
 					placeholder={none}
 					placeholderUntilEdit
-					{example}
 					labelledBy={domIds.label}
 					{describedBy}
 					{leafKey}
@@ -350,7 +347,8 @@
 				<DateField
 					bind:this={dateEl}
 					value={value as string | undefined}
-					fallback={defaultStr}
+					fallback={stringifyGhost(field.schema.default)}
+					datetime={baseType(field.schema) === 'datetime'}
 					labelledBy={domIds.label}
 					{describedBy}
 					onCommit={onCommitScalar}
@@ -405,7 +403,6 @@
 					value={value as string | undefined}
 					fallback={declared}
 					placeholder={none}
-					{example}
 					id={domIds.control}
 					{describedBy}
 					onCommit={onCommitScalar}

package/dist/visual/NumberField.svelte

@@ -1,7 +1,7 @@
 <!--
  A `number` / `integer` field → numeric input (fixture `font_size` = 11.5).
  Commits at `change` (blur/Enter), not per keystroke: a partial numeric entry
- (`-`, `1.`, `1e`) is never a document state worth a boundary round-trip, and
+ (`-`, `1.`) is never a document state worth a boundary round-trip, and
  committing it live flashes a coercion diagnostic + `console.error` on every
  intermediate prefix, announced by `DiagnosticList`'s `role="status"` live
  region.
@@ -12,15 +12,21 @@
  so a blank entry commits `undefined`, the unset rung: the parent removes the field,
  the engine renders the default, and the input holds it again.
 
- `type="text"`, not `type="number"`: a native number input sanitizes an
- invalid string to `""` before the DOM `value` setter even runs (verified:
- `.value = "abc"` on `type="number"` never lands), which would make a
- genuinely bad entry untypeable. The commit-time coercion diagnostic
- (VISUAL_EDITOR §Diagnostics) needs exactly that path reachable through the
- UI, so a non-blank entry that fails to parse forwards the raw string to
- `onCommit` unchanged: the boundary's own `writer.set` coercion is the judge
- (throws a `QuillmarkError` the parent turns into a field diagnostic), not a
- client-side guess. `inputmode` keeps the numeric mobile keyboard.
+ The entry grammar is plain decimal: an optional sign and digits, and for a `number`
+ a `.` and an exponent, the form `String()` gives a value too small or large for
+ digits. A keystroke that leaves the text outside a prefix of it does not land, and in
+ a `number` a `,` lands as `.`, the decimal key of a comma locale's keypad. A deletion
+ always lands, so a stored value outside the grammar (`abc`) can be cleared, and a
+ paste, a drop or an IME composition lands as it comes, judged when it settles.
+ `type="text"`, not `type="number"`: a native number input sanitizes an invalid
+ string to `""` rather than showing it, and steps on a scroll-wheel. `inputmode`
+ keeps the numeric mobile keyboard.
+
+ A settled entry in the grammar commits as a number. Anything else forwards the raw
+ string to `onCommit`: the boundary's `writer.set` coercion is the judge (throws a
+ `QuillmarkError` the parent turns into a field diagnostic, VISUAL_EDITOR
+ §Diagnostics). `Number()` alone is no gate: it reads `0x1F` and `Infinity` as
+ numbers, and `1.000` as a whole one.
 -->
 <script lang="ts">
 	import { syncedLocal } from './synced.svelte.js';
@@ -53,22 +59,42 @@
 	const local = syncedLocal(() => (value != null ? String(value) : (fallback ?? '')));
 	const defaulted = $derived(value == null && !!fallback && local.value === fallback);
 
+	const partial = $derived(
+		integer ? /^\s*[+-]?\d*\s*$/ : /^\s*[+-]?\d*\.?\d*(?:[eE][+-]?\d*)?\s*$/
+	);
+	const whole = $derived(integer ? /^[+-]?\d+$/ : /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/);
+
+	function filter(e: InputEvent): void {
+		if (e.inputType !== 'insertText' || e.data == null) return;
+		const el = e.currentTarget as HTMLInputElement;
+		const from = el.selectionStart ?? el.value.length;
+		const to = el.selectionEnd ?? el.value.length;
+		const data = !integer && e.data === ',' ? '.' : e.data;
+		const next = el.value.slice(0, from) + data + el.value.slice(to);
+		if (!partial.test(next)) return e.preventDefault();
+		if (data === e.data) return;
+		e.preventDefault();
+		// `insertText` lands on the undo stack and fires `input`; `setRangeText` does neither.
+		if (document.execCommand?.('insertText', false, data)) return;
+		el.setRangeText(data, from, to, 'end');
+		local.value = el.value;
+	}
+
 	// Parse a settled entry and emit it; `local` is owned by `oninput`. Blank →
 	// `undefined`, and the input takes the default back: nothing else reconciles it, the
 	// projection having read the default throughout. Onto the element as well, since the
 	// attribute Svelte last wrote may already be the default, and it writes no repeat.
 	function commit(el: HTMLInputElement): void {
 		const raw = el.value;
-		if (raw.trim() === '') {
+		const entry = raw.trim();
+		if (entry === '') {
 			onCommit(undefined);
 			local.value = el.value = fallback ?? '';
 			return;
 		}
-		// Number(), not parseFloat/parseInt: a prefix parse would silently commit
-		// `14.5` for `14.5x` (and truncate `11.9` → 11 on integer fields) instead
-		// of letting the boundary judge the full entry.
-		const n = Number(raw);
-		onCommit(Number.isNaN(n) ? raw : n);
+		// Finite as well: a digit run past `Number.MAX_VALUE` reads as `Infinity`.
+		const n = whole.test(entry) ? Number(entry) : NaN;
+		onCommit(Number.isFinite(n) ? n : raw);
 	}
 </script>
 
@@ -82,6 +108,7 @@
 	data-default={defaulted ? '' : undefined}
 	aria-label={id ? undefined : label}
 	aria-describedby={describedBy}
+	onbeforeinput={filter}
 	oninput={(e) => {
 		local.value = (e.currentTarget as HTMLInputElement).value;
 	}}

package/dist/visual/ObjectField.svelte

@@ -39,7 +39,6 @@
 		baseType,
 		controlKind,
 		declaredContent,
-		exampleGhost,
 		humanize,
 		isContainer,
 		mountKey,
@@ -134,9 +133,6 @@
 	 *  cell ghosts nothing, an empty answer printing empty. */
 	const noneOf = (key: string, sub: QuillFieldSchema): string | undefined =>
 		obj[key] == null && optionalCell(sub) ? t.strings.optionalGhost : undefined;
-	/** What an unset free-text cell ghosts where nothing prints ({@link exampleGhost}). */
-	const exampleOf = (key: string, sub: QuillFieldSchema): string | undefined =>
-		obj[key] == null ? exampleGhost(sub) : undefined;
 	/** A scalar cell's `default:` as the text an unset cell holds, where it prints. */
 	const textDefault = (sub: QuillFieldSchema): string | undefined => printedText(sub.default);
 	/** A content cell's `default:` as the content an unset leaf holds, where it prints. */
@@ -338,6 +334,7 @@
 						describedBy={describes}
 						value={obj[key] as string | undefined}
 						fallback={sub.default != null ? String(sub.default) : undefined}
+						datetime={baseType(sub) === 'datetime'}
 						onCommit={(v) => commitProp(key, v)}
 					/>
 				{:else if kind === 'text'}
@@ -348,7 +345,6 @@
 						value={obj[key] as string | undefined}
 						fallback={textDefault(sub)}
 						placeholder={noneOf(key, sub)}
-						example={exampleOf(key, sub)}
 						onCommit={(v) => commitProp(key, v)}
 						onKey={onCellKey ? (e) => onCellKey(e, key) : undefined}
 					/>
@@ -361,7 +357,6 @@
 						fallback={contentDefault(sub)}
 						plaintext={baseType(sub) === 'plaintext'}
 						placeholder={noneOf(key, sub)}
-						example={exampleOf(key, sub)}
 						{block}
 						label={named}
 						labelledBy={ids?.label}

package/dist/visual/ProseField.svelte

@@ -43,12 +43,8 @@
 		/** Ghost shown on the empty leaf: the `none` an optional field prints unset, or
 		 * nothing, and a body's always text (`resolveBodyGhost`). */
 		placeholder?: string;
-		/** A field's leaf, whose placeholder goes at its first edit (`createField`). */
+		/** The placeholder goes at the leaf's first edit (`createField`). */
 		placeholderUntilEdit?: boolean;
-		/** Ghost shown on the empty leaf until its first edit, and in the placeholder's
-		 * stead while the leaf holds the focus: an unset field's `example:`
-		 * (`exampleGhost`). */
-		example?: string;
 		/** Registry identity, stamped on the DOM node so a remount is visible as one. */
 		leafKey: string;
 		onFocus?: (addr: Addr) => void;
@@ -77,7 +73,6 @@
 		fallback,
 		placeholder,
 		placeholderUntilEdit,
-		example,
 		leafKey,
 		onFocus,
 		onCaretMove,
@@ -128,7 +123,6 @@
 			fallback,
 			placeholder,
 			placeholderUntilEdit,
-			example,
 			tableStrings: () => t.strings,
 			onSlash: (next) => {
 				slash = next;
@@ -156,9 +150,6 @@
 	$effect(() => {
 		controller?.setPlaceholder(placeholder);
 	});
-	$effect(() => {
-		controller?.setExample(example);
-	});
 	$effect(() => {
 		controller?.setFallback(fallback);
 	});

package/dist/visual/ProseField.svelte.d.ts

@@ -31,12 +31,8 @@ interface Props {
     /** Ghost shown on the empty leaf: the `none` an optional field prints unset, or
      * nothing, and a body's always text (`resolveBodyGhost`). */
     placeholder?: string;
-    /** A field's leaf, whose placeholder goes at its first edit (`createField`). */
+    /** The placeholder goes at the leaf's first edit (`createField`). */
     placeholderUntilEdit?: boolean;
-    /** Ghost shown on the empty leaf until its first edit, and in the placeholder's
-     * stead while the leaf holds the focus: an unset field's `example:`
-     * (`exampleGhost`). */
-    example?: string;
     /** Registry identity, stamped on the DOM node so a remount is visible as one. */
     leafKey: string;
     onFocus?: (addr: Addr) => void;

package/dist/visual/ProseValue.svelte

@@ -76,12 +76,9 @@
 		labelledBy?: string;
 		/** The parked `description` (FieldLabel) → `aria-describedby`. */
 		describedBy?: string;
-		/** The empty leaf's ghosts, a subform cell's, until the leaf's first edit: the
-		 *  `none` an optional cell prints unset, and the `example:` drawn where there is no
-		 *  placeholder and in its stead while the leaf holds the focus (`createField`'s
-		 *  pair). Read per decoration pass. */
+		/** The empty leaf's ghost, a subform cell's, until the leaf's first edit: the
+		 *  `none` an optional cell prints unset. Read per decoration pass. */
 		placeholder?: string;
-		example?: string;
 		onChange: (rt: Content) => void;
 		/** Raw keydown, for a container whose own keys run through this leaf: the
 		 * array repeater's Enter/Backspace (`ArrayField`). Fires before the view's own
@@ -97,7 +94,6 @@
 		labelledBy,
 		describedBy,
 		placeholder,
-		example,
 		onChange,
 		onKey
 	}: Props = $props();
@@ -160,8 +156,7 @@
 				: proseLeafPlugins(schema, {
 						inline,
 						placeholder: () => placeholder,
-						placeholderUntilEdit: true,
-						example: () => example
+						placeholderUntilEdit: true
 					})
 		});
 		const mounted = new EditorView(

package/dist/visual/ProseValue.svelte.d.ts

@@ -25,12 +25,9 @@ interface Props {
     labelledBy?: string;
     /** The parked `description` (FieldLabel) → `aria-describedby`. */
     describedBy?: string;
-    /** The empty leaf's ghosts, a subform cell's, until the leaf's first edit: the
-     *  `none` an optional cell prints unset, and the `example:` drawn where there is no
-     *  placeholder and in its stead while the leaf holds the focus (`createField`'s
-     *  pair). Read per decoration pass. */
+    /** The empty leaf's ghost, a subform cell's, until the leaf's first edit: the
+     *  `none` an optional cell prints unset. Read per decoration pass. */
     placeholder?: string;
-    example?: string;
     onChange: (rt: Content) => void;
     /** Raw keydown, for a container whose own keys run through this leaf: the
      * array repeater's Enter/Backspace (`ArrayField`). Fires before the view's own

package/dist/visual/TextField.svelte

@@ -24,9 +24,6 @@
 		/** Words at rest about an unset field that holds no text: the `None` an optional
 		 * cell prints. */
 		placeholder?: string;
-		/** An unset field's `example:` (`exampleGhost`): drawn wherever the field holds no
-		 * text, and in `placeholder`'s stead while the input holds the focus. */
-		example?: string;
 		/** Accessible name for an input nothing else names: an array element, whose
 		 * name is the field label plus its 1-based index. A field's own input takes
 		 * `id` instead and is named by the `<label for>` beside it. */
@@ -41,8 +38,7 @@
 		 * array repeater's Enter/Backspace (`ArrayField`). */
 		onKey?: (e: KeyboardEvent) => void;
 	}
-	let { value, fallback, placeholder, example, label, id, describedBy, onCommit, onKey }: Props =
-		$props();
+	let { value, fallback, placeholder, label, id, describedBy, onCommit, onKey }: Props = $props();
 
 	// Local input state synced to `value`, or to the default an unset field holds:
 	// own-typing stays local, only an external change reconciles back in (see
@@ -50,9 +46,6 @@
 	const local = syncedLocal(() => value ?? fallback ?? '');
 	const defaulted = $derived(value == null && !!fallback && local.value === fallback);
 
-	let focused = $state(false);
-	const ghost = $derived(focused ? (example ?? placeholder) : (placeholder ?? example));
-
 	let inputEl: HTMLInputElement | undefined = $state();
 	/** Take the caret: what a parent placing focus on this control calls. */
 	export function focus(): void {
@@ -66,13 +59,11 @@
 	type="text"
 	value={local.value}
 	{id}
-	placeholder={ghost}
+	{placeholder}
 	data-default={defaulted ? '' : undefined}
 	aria-label={id ? undefined : label}
 	aria-describedby={describedBy}
 	onkeydown={onKey}
-	onfocus={() => (focused = true)}
-	onblur={() => (focused = false)}
 	oninput={(e) => {
 		local.value = (e.currentTarget as HTMLInputElement).value;
 		onCommit(local.value !== '' ? local.value : fallback ? '' : undefined);

package/dist/visual/TextField.svelte.d.ts

@@ -6,9 +6,6 @@ interface Props {
     /** Words at rest about an unset field that holds no text: the `None` an optional
      * cell prints. */
     placeholder?: string;
-    /** An unset field's `example:` (`exampleGhost`): drawn wherever the field holds no
-     * text, and in `placeholder`'s stead while the input holds the focus. */
-    example?: string;
     /** Accessible name for an input nothing else names: an array element, whose
      * name is the field label plus its 1-based index. A field's own input takes
      * `id` instead and is named by the `<label for>` beside it. */

package/dist/visual/VisualEditorInner.svelte

@@ -63,7 +63,6 @@
 		provenanceMap,
 		resolvedByCardIndex,
 		ghostDefault,
-		declaredGhost,
 		titleText,
 		resolveBodyGhost,
 		NO_RESOLVED_ROWS,
@@ -612,7 +611,6 @@
 			bodyGhost: hasBody
 				? resolveBodyGhost(
 						titleText(ghostDefault(rows.body ?? undefined)) || undefined,
-						declaredGhost(cardSchema?.body?.example, true),
 						merged.bodyPlaceholder?.({ cardId: id, kind, isMain }),
 						merged.bodyGhost
 					)

package/dist/visual/controls.css

@@ -112,7 +112,7 @@
 	color: var(--_qm-ink-default);
 }
 /* The native placeholder is the label rung, not the UA's own grey: what an input
-   ghosts is words about a value it does not hold — an `example:`, `None` — which is
+   ghosts is words about a value it does not hold — `None` — which is
    content and reads at a content's contrast, the same step the prose leaf's ghost
    reads (`prose.css`). */
 :where(.qm-input)::placeholder {

package/dist/visual/icons/nodes.d.ts

@@ -119,6 +119,34 @@ export declare const ICONS: {
     readonly check: readonly [readonly ["path", {
         readonly d: "M20 6 9 17l-5-5";
     }]];
+    readonly calendar: readonly [readonly ["path", {
+        readonly d: "M8 2v3";
+    }], readonly ["path", {
+        readonly d: "M16 2v3";
+    }], readonly ["rect", {
+        readonly x: "3";
+        readonly y: "3";
+        readonly width: "18";
+        readonly height: "18";
+        readonly rx: "2";
+    }], readonly ["path", {
+        readonly d: "M3 9h18";
+    }]];
+    readonly 'calendar-check': readonly [readonly ["path", {
+        readonly d: "M8 2v3";
+    }], readonly ["path", {
+        readonly d: "M16 2v3";
+    }], readonly ["rect", {
+        readonly x: "3";
+        readonly y: "3";
+        readonly width: "18";
+        readonly height: "18";
+        readonly rx: "2";
+    }], readonly ["path", {
+        readonly d: "M3 9h18";
+    }], readonly ["path", {
+        readonly d: "m9 15 2 2 4-4";
+    }]];
 };
 /** The closed set. A name that is not here is a compile error at the call site,
  *  which is what a string key buys over thirteen imported components. */

package/dist/visual/icons/nodes.js

@@ -64,5 +64,18 @@ export const ICONS = {
         ['path', { d: 'M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2' }]
     ],
     minus: [['path', { d: 'M5 12h14' }]],
-    check: [['path', { d: 'M20 6 9 17l-5-5' }]]
+    check: [['path', { d: 'M20 6 9 17l-5-5' }]],
+    calendar: [
+        ['path', { d: 'M8 2v3' }],
+        ['path', { d: 'M16 2v3' }],
+        ['rect', { x: '3', y: '3', width: '18', height: '18', rx: '2' }],
+        ['path', { d: 'M3 9h18' }]
+    ],
+    'calendar-check': [
+        ['path', { d: 'M8 2v3' }],
+        ['path', { d: 'M16 2v3' }],
+        ['rect', { x: '3', y: '3', width: '18', height: '18', rx: '2' }],
+        ['path', { d: 'M3 9h18' }],
+        ['path', { d: 'm9 15 2 2 4-4' }]
+    ]
 };

package/dist/visual/strings.d.ts

@@ -47,6 +47,9 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     enumUnsetTag: string;
     /** The count in the matrix's label row: how many of the roster are held. */
     matrixHeld: (held: number, total: number) => string;
+    /** The date field's toggle, pressed while the field holds `today`: the render
+     *  date rather than a written one. */
+    dateToday: string;
     /** The required marker's accessible name; the glyph itself is a `*`. */
     fieldRequired: string;
     /** What an unset optional cell (`t?`) ghosts at rest: the `none` it prints

package/dist/visual/strings.js

@@ -37,6 +37,7 @@ export const DEFAULT_VISUAL_STRINGS = {
     elementUntitled: (label, index) => `${label} ${index}`,
     enumUnsetTag: 'default',
     matrixHeld: (held, total) => `${held} of ${total} held`,
+    dateToday: 'Today',
     fieldRequired: 'required',
     optionalGhost: 'None',
     proseHeld: 'Holds more than this field can edit here.',

package/dist/visual/structure.d.ts

@@ -138,32 +138,23 @@ export interface BodyPlaceholderContext {
  */
 export type BodyPlaceholder = (ctx: BodyPlaceholderContext) => string | undefined;
 /**
- * The empty body's ghost: the resolved body `default:`, else the kind's
- * `body.example`, else the consumer's wording, else the flat built-in. The
- * `default:` wins because it is the only one that describes the render: it promises
- * what prints if nothing is written, and wording placed over it would make that
- * promise unreadable. The rest are invitations, and an invitation belongs only where
- * there is no promise; the quill's own comes first, being the one an agent working
- * from the blueprint sees too.
+ * The empty body's ghost: the resolved body `default:`, else the consumer's wording,
+ * else the flat built-in. The `default:` wins because it is the only one that
+ * describes the render: it promises what prints if nothing is written, and wording
+ * placed over it would make that promise unreadable. The rest are invitations, and an
+ * invitation belongs only where there is no promise.
  */
-export declare function resolveBodyGhost(resolvedDefault: string | undefined, example: string | undefined, custom: string | undefined, builtIn: string): string;
+export declare function resolveBodyGhost(resolvedDefault: string | undefined, custom: string | undefined, builtIn: string): string;
 /** Whether a cell is optional: a `t?` type, which renders `none` unanswered and so
  *  never declares a `default:` (canon `SCHEMAS.md` §"Optional cells"). */
 export declare function optionalCell(f: QuillFieldSchema): boolean;
 /** The type a cell's control reads: the declared one, an optional cell's `?` stripped.
  *  The `?` moves the render floor and nothing else, so every read of a type is this. */
 export declare function baseType(f: QuillFieldSchema): QuillFieldType;
-/**
- * A value the schema declares, as ghost text: a `default:`, an `example:` or a
- * `body.example`. Markdown — a `richtext` value — ghosts as the text it renders, one
- * block to a line, as a resolved default does ({@link titleText}); anything else as
- * itself. `undefined` for a blank or a non-scalar.
- */
-export declare function declaredGhost(v: unknown, markdown: boolean): string | undefined;
 /**
  * A scalar `default:` as the text an unset control holds, where it prints: as
  * declared, `undefined` for none, a blank or a non-scalar. A default of spaces prints
- * nothing a reader sees, so a control holds none and draws its example instead.
+ * nothing a reader sees, so a control holds none.
  */
 export declare function printedText(v: unknown): string | undefined;
 /**
@@ -174,13 +165,6 @@ export declare function printedText(v: unknown): string | undefined;
  * a blank or a non-scalar.
  */
 export declare function declaredContent(v: unknown, markdown: boolean): Content | undefined;
-/**
- * The `example:` an unset free-text cell ghosts: a `string`, `plaintext` or `richtext`
- * whose `default:` prints nothing. Every other type takes none. A default that prints
- * dominates, standing in the control as the value it is; a type-empty one, the
- * skippable marker, prints nothing and leaves the example the only thing to draw.
- */
-export declare function exampleGhost(f: QuillFieldSchema): string | undefined;
 /** A field's `{#each}` key: its name and what a mounted leaf reads once, its type and
  *  `inline` and its elements'. A retype or a quill swap that changes any of them under a
  *  name remounts the field, where a kept leaf would commit on the old schema. */

package/dist/visual/structure.js

@@ -48,16 +48,14 @@ export function stringifyGhost(ghost) {
     return ghost != null && typeof ghost !== 'object' ? String(ghost) : undefined;
 }
 /**
- * The empty body's ghost: the resolved body `default:`, else the kind's
- * `body.example`, else the consumer's wording, else the flat built-in. The
- * `default:` wins because it is the only one that describes the render: it promises
- * what prints if nothing is written, and wording placed over it would make that
- * promise unreadable. The rest are invitations, and an invitation belongs only where
- * there is no promise; the quill's own comes first, being the one an agent working
- * from the blueprint sees too.
+ * The empty body's ghost: the resolved body `default:`, else the consumer's wording,
+ * else the flat built-in. The `default:` wins because it is the only one that
+ * describes the render: it promises what prints if nothing is written, and wording
+ * placed over it would make that promise unreadable. The rest are invitations, and an
+ * invitation belongs only where there is no promise.
  */
-export function resolveBodyGhost(resolvedDefault, example, custom, builtIn) {
-    return resolvedDefault || example || custom || builtIn;
+export function resolveBodyGhost(resolvedDefault, custom, builtIn) {
+    return resolvedDefault || custom || builtIn;
 }
 /** Whether a cell is optional: a `t?` type, which renders `none` unanswered and so
  *  never declares a `default:` (canon `SCHEMAS.md` §"Optional cells"). */
@@ -69,22 +67,10 @@ export function optionalCell(f) {
 export function baseType(f) {
     return (optionalCell(f) ? f.type.slice(0, -1) : f.type);
 }
-/**
- * A value the schema declares, as ghost text: a `default:`, an `example:` or a
- * `body.example`. Markdown — a `richtext` value — ghosts as the text it renders, one
- * block to a line, as a resolved default does ({@link titleText}); anything else as
- * itself. `undefined` for a blank or a non-scalar.
- */
-export function declaredGhost(v, markdown) {
-    const text = stringifyGhost(v)?.trim();
-    if (!text)
-        return undefined;
-    return (markdown ? core().importMarkdown(text).text.trim() : text) || undefined;
-}
 /**
  * A scalar `default:` as the text an unset control holds, where it prints: as
  * declared, `undefined` for none, a blank or a non-scalar. A default of spaces prints
- * nothing a reader sees, so a control holds none and draws its example instead.
+ * nothing a reader sees, so a control holds none.
  */
 export function printedText(v) {
     const text = stringifyGhost(v);
@@ -114,21 +100,6 @@ export function declaredContent(v, markdown) {
         islands: []
     };
 }
-/**
- * The `example:` an unset free-text cell ghosts: a `string`, `plaintext` or `richtext`
- * whose `default:` prints nothing. Every other type takes none. A default that prints
- * dominates, standing in the control as the value it is; a type-empty one, the
- * skippable marker, prints nothing and leaves the example the only thing to draw.
- */
-export function exampleGhost(f) {
-    const kind = controlKind(f);
-    if (kind !== 'text' && kind !== 'prose')
-        return undefined;
-    const markdown = baseType(f) === 'richtext';
-    if (declaredGhost(f.default, markdown) !== undefined)
-        return undefined;
-    return declaredGhost(f.example, markdown);
-}
 /** A field's `{#each}` key: its name and what a mounted leaf reads once, its type and
  *  `inline` and its elements'. A retype or a quill swap that changes any of them under a
  *  name remounts the field, where a kept leaf would commit on the old schema. */
@@ -323,21 +294,20 @@ export function shortCell(sub) {
     return (kind === 'text' || kind === 'enum' || kind === 'number' || kind === 'boolean' || kind === 'date');
 }
 /**
- * The first short text cell's words, in declaration order — a `string`, or an inline
- * `richtext` / `plaintext` — read through {@link titleText}; `undefined` while none of
- * them has any. What names an instance from its own values: a collapsed row, and a
- * card whose kind declares no `title`.
+ * The first short text cell's words — the first `string`, or inline `richtext` /
+ * `plaintext`, in declaration order — read through {@link titleText}; `undefined` where
+ * there is no such cell or it is empty. The cell is picked by the schema alone, so an
+ * instance is named by one cell whatever the others hold. What names an instance from
+ * its own values: a collapsed row, and a card whose kind declares no `title`.
  */
 function firstShortText(cells, values) {
-    for (const [k, sub] of Object.entries(cells ?? {})) {
+    const named = Object.entries(cells ?? {}).find(([, sub]) => {
         const kind = controlKind(sub);
-        if (kind !== 'text' && !(kind === 'prose' && shortCell(sub)))
-            continue;
-        const text = titleText(ownValue(values, k)).trim();
-        if (text)
-            return text;
-    }
-    return undefined;
+        return kind === 'text' || (kind === 'prose' && shortCell(sub));
+    });
+    if (!named)
+        return undefined;
+    return titleText(ownValue(values, named[0])).trim() || undefined;
 }
 /** A collapsed row's own words ({@link firstShortText}); `undefined` while the row has
  *  nothing to say for itself. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.13.0",
+	"version": "0.15.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -66,7 +66,7 @@
 		"check": "svelte-check --tsconfig ./tsconfig.json"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.116.0-0",
+		"@quillmark/wasm": ">=0.117.0-0",
 		"svelte": "^5.0.0"
 	},
 	"dependencies": {