@marianmeres/stuic 3.140.0 → 3.142.0

package/dist/components/Backdrop/Backdrop.svelte

@@ -15,6 +15,11 @@
 		transitionEnabled?: boolean;
 		el?: HTMLDivElement;
 		children?: Snippet;
+		/**
+		 * Fired on Escape while visible. **Notify-only** — Backdrop does not close
+		 * itself; the caller owns close via `bind:visible` or `close()`. The return
+		 * value is ignored (there is no Escape veto here, unlike `Modal.onEscape`).
+		 */
 		onEscape?: () => void;
 		onBackdropClick?: () => void;
 		visible?: boolean;

package/dist/components/Backdrop/Backdrop.svelte.d.ts

@@ -8,6 +8,11 @@ export interface Props extends Record<string, any> {
     transitionEnabled?: boolean;
     el?: HTMLDivElement;
     children?: Snippet;
+    /**
+     * Fired on Escape while visible. **Notify-only** — Backdrop does not close
+     * itself; the caller owns close via `bind:visible` or `close()`. The return
+     * value is ignored (there is no Escape veto here, unlike `Modal.onEscape`).
+     */
     onEscape?: () => void;
     onBackdropClick?: () => void;
     visible?: boolean;

package/dist/components/CronInput/CronInput.svelte

@@ -187,7 +187,7 @@
 </script>
 
 <script lang="ts">
-	import { CronParser } from "@marianmeres/cron";
+	import { CronParser } from "@marianmeres/cron-parser";
 	import {
 		validate as validateAction,
 		type ValidationResult,

package/dist/components/CronInput/README.md

@@ -1,6 +1,6 @@
 # CronInput
 
-A cron-expression editor with three progressive surfaces: **preset picker**, **5-field visual editor**, and **raw expression input** — plus a human-readable summary and the next-run preview. Backed by [`@marianmeres/cron`](https://www.npmjs.com/package/@marianmeres/cron).
+A cron-expression editor with three progressive surfaces: **preset picker**, **5-field visual editor**, and **raw expression input** — plus a human-readable summary and the next-run preview. Backed by [`@marianmeres/cron-parser`](https://www.npmjs.com/package/@marianmeres/cron-parser).
 
 The cron expression string is the single source of truth; field / preset / raw surfaces are all views over it. All three stay in sync automatically when the bound `value` changes.
 
@@ -109,7 +109,7 @@ The component uses `new CronParser(value)` to validate. When invalid:
 
 ## Timezone
 
-All next-run calculations use the **host's local timezone**. There is no `timezone` prop today. DST transitions are handled correctly by `@marianmeres/cron`, but the displayed "next run" will naturally follow local-time semantics.
+All next-run calculations use the **host's local timezone**. There is no `timezone` prop today. DST transitions are handled correctly by `@marianmeres/cron-parser`, but the displayed "next run" will naturally follow local-time semantics.
 
 ## Props
 

package/dist/components/CronInput/cron-next-run.svelte.js

@@ -1,4 +1,4 @@
-import { CronParser } from "@marianmeres/cron";
+import { CronParser } from "@marianmeres/cron-parser";
 /**
  * A reactive helper that parses a cron expression and computes the next run time,
  * updating automatically every minute.

package/dist/components/Drawer/Drawer.svelte

@@ -16,6 +16,11 @@
 		focusTrap?: boolean | FocusTrapOptions;
 		/** Used in `fly` config. Should match tw classes for optimal animation. May include css units. */
 		animOffset?: string | number;
+		/**
+		 * Fired on Escape while open. **Notify-only** — Drawer does not close itself
+		 * (it forwards to Backdrop); the caller owns close via `bind:visible` or
+		 * `close()`. The return value is ignored (no Escape veto, unlike `Modal`).
+		 */
 		onEscape?: () => void;
 		onOutside?: () => void;
 		noBackdropScrollLock?: boolean;

package/dist/components/Drawer/Drawer.svelte.d.ts

@@ -14,6 +14,11 @@ export interface Props {
     focusTrap?: boolean | FocusTrapOptions;
     /** Used in `fly` config. Should match tw classes for optimal animation. May include css units. */
     animOffset?: string | number;
+    /**
+     * Fired on Escape while open. **Notify-only** — Drawer does not close itself
+     * (it forwards to Backdrop); the caller owns close via `bind:visible` or
+     * `close()`. The return value is ignored (no Escape veto, unlike `Modal`).
+     */
     onEscape?: () => void;
     onOutside?: () => void;
     noBackdropScrollLock?: boolean;

package/dist/components/Input/FieldAssets.svelte

@@ -131,6 +131,93 @@
 		return map[getFileTypeLabel(ext ?? "unknown")] ?? iconFile;
 	}
 
+	// --- Clipboard paste plumbing (see the `pasteable` prop) -------------------
+	// All mounted pasteable instances coordinate through ONE document-level
+	// `paste` listener (installed while at least one is mounted). Document-level
+	// (rather than a listener on the field wrapper) because browsers dispatch
+	// `paste` at the focused/selection node — with focus on <body> the event
+	// never bubbles through the field, which made the feature look dead unless
+	// the field was clicked first.
+	type PasteTarget = {
+		el: HTMLElement;
+		handle: (e: ClipboardEvent) => void;
+	};
+
+	const paste_targets = new Set<PasteTarget>();
+
+	// True only when NOTHING is focused (browsers park focus on <body>/<html>).
+	// The fallback below must never fire while the user has deliberately focused
+	// some other element — a text input obviously, but also any other widget
+	// (e.g. a different, non-pasteable FieldAssets): pasting "into" the thing
+	// they focused must not teleport files to an unrelated field.
+	function is_unclaimed_focus(el: Element | null): boolean {
+		return !el || el === document.body || el === document.documentElement;
+	}
+
+	// Text-entry elements own their pastes even when they live INSIDE the field
+	// (consumer content via the label/description/below snippets) — an editor's
+	// image paste must insert into the editor, not upload into the field.
+	function is_text_entry(el: Element | null): boolean {
+		if (!el) return false;
+		if ((el as HTMLElement).isContentEditable) return true;
+		return ["INPUT", "TEXTAREA", "SELECT"].includes(el.tagName);
+	}
+
+	// A field hidden by CSS (kept-mounted inactive tab panel etc.) must not
+	// claim the no-focus fallback — the user would see nothing happen.
+	function is_visible(el: HTMLElement): boolean {
+		return el.checkVisibility?.() ?? el.offsetParent !== null;
+	}
+
+	// A modal/dialog (drawer, modal) takes focus on open, so `active` is the
+	// dialog panel — or a control inside it — and NEVER <body>. When the field
+	// lives in such a dialog, treat a non-text focus within that SAME dialog as
+	// unclaimed too, so a bare Ctrl/Cmd-V attaches with no prior click. Scoped to
+	// a shared [aria-modal]/[role=dialog] ancestor on purpose: it must not make
+	// the field greedy on ordinary (non-modal) pages, where a deliberately
+	// focused control elsewhere still owns its paste.
+	function shares_modal(fieldEl: HTMLElement, active: Element | null): boolean {
+		if (!active) return false;
+		const modal = fieldEl.closest?.("[aria-modal='true'],[role='dialog']");
+		return !!modal && modal.contains(active);
+	}
+
+	function on_document_paste(e: ClipboardEvent) {
+		// someone (an editor, another paste handler) already claimed it
+		if (e.defaultPrevented) return;
+		const active = document.activeElement;
+		// 1) the field holding focus always wins — unless focus sits in a
+		// text-entry element nested inside it: stand down entirely
+		for (const t of paste_targets) {
+			if (t.el.contains(active)) {
+				if (is_text_entry(active)) return;
+				return t.handle(e);
+			}
+		}
+		// 2) fall back to the SINGLE mounted + visible pasteable field for a paste
+		// NOT owned by a focused text-entry element, when focus is EITHER unclaimed
+		// (fresh page, focus on <body>) OR parked on a non-text control inside the
+		// SAME modal/dialog as the field (the drawer/modal case: the panel or the
+		// row that opened it holds focus, so <body> is never active). A bare
+		// Ctrl/Cmd-V then works with no prior click. With several fields mounted the
+		// routing would be ambiguous, so focus (a click on the field) must decide.
+		if (paste_targets.size === 1 && !is_text_entry(active)) {
+			const [t] = paste_targets;
+			if (is_visible(t.el) && (is_unclaimed_focus(active) || shares_modal(t.el, active))) {
+				t.handle(e);
+			}
+		}
+	}
+
+	function register_paste_target(t: PasteTarget): () => void {
+		if (!paste_targets.size) document.addEventListener("paste", on_document_paste);
+		paste_targets.add(t);
+		return () => {
+			paste_targets.delete(t);
+			if (!paste_targets.size) document.removeEventListener("paste", on_document_paste);
+		};
+	}
+
 	type SnippetWithId = Snippet<[{ id: string }]>;
 
 	export interface Props extends InputWrapClassProps, Record<string, any> {
@@ -189,11 +276,22 @@
 		ordered?: boolean;
 		/**
 		 * Opt-in: allow pasting image/file data from the clipboard (Ctrl/Cmd-V) into
-		 * the field. Focus-scoped — the paste is consumed only while the field (or a
-		 * control inside it) holds focus; clicking anywhere in the field focuses it,
-		 * so no Tab is needed. Routed through the same validation + upload path as
-		 * drag and the file picker, so `accept`, `cardinality` and `processAssets`
-		 * all apply. No-op unless `processAssets` is provided. Default `false`.
+		 * the field. Routing: a paste is consumed while the field (or a control
+		 * inside it) holds focus — clicking anywhere in the field focuses it. On
+		 * top of that, a bare Ctrl/Cmd-V with no prior click is routed here — as
+		 * long as this is the only pasteable + visible FieldAssets on the page —
+		 * when focus is NOT in a text-entry element and is either unclaimed (fresh
+		 * page, focus parked on <body>) or parked on a non-text control inside the
+		 * SAME modal/dialog as the field (a drawer/modal takes focus on open, so
+		 * <body> is never active there). Focus elsewhere is respected and never
+		 * hijacked: not a text
+		 * input/textarea/select/contenteditable (even one nested inside the field
+		 * via the label/description/below snippets), not any other widget; with
+		 * several pasteable fields mounted, click (focus) one to pick the
+		 * destination. Disabled and `isLoading` fields take no pastes. Pasted
+		 * files share the validation + upload path with drag and the file picker
+		 * (`accept`, `cardinality` and `processAssets` all apply). No-op unless
+		 * `processAssets` is provided. Default `false`.
 		 */
 		pasteable?: boolean;
 		//
@@ -526,11 +624,12 @@
 	}
 
 	// --- Clipboard paste (opt-in via `pasteable`) -------------------------------
-	// Focus-scoped: the paste listener lives on the field wrapper, so it only fires
-	// while the field (or a control inside it) holds focus. `focusForPaste` focuses
-	// the wrapper on any click within it, so a click + Ctrl/Cmd-V works with no Tab.
-	// Pasted files go through `handleIncomingFiles`, inheriting accept/cardinality
-	// validation and the processAssets upload — no synthetic `change` event.
+	// Wired through the module-level document `paste` listener (see PasteTarget
+	// above): the instance registers itself while mounted, and receives the paste
+	// when it holds focus — or, as the only mounted pasteable field, when the
+	// paste is unclaimed (focus not in a text-entry element). Pasted files go
+	// through `handleIncomingFiles`, inheriting accept/cardinality validation and
+	// the processAssets upload — no synthetic `change` event.
 	function extractClipboardFiles(e: ClipboardEvent): File[] {
 		const dt = e.clipboardData;
 		if (!dt) return [];
@@ -556,11 +655,11 @@
 		handleIncomingFiles(files);
 	}
 
-	// Focus the wrapper on any click inside it so a following paste lands here.
-	// Capture phase: fires even though the inner thumbnail/control buttons
-	// stopPropagation, and even in browsers that don't focus <button> on click
-	// (Safari/Firefox on macOS). Skipped when focus is already inside the field —
-	// paste bubbles from any focused descendant anyway.
+	// Focus the wrapper on any click inside it so a following paste routes here
+	// (the document-level listener routes by focus containment). Capture phase:
+	// fires even though the inner thumbnail/control buttons stopPropagation, and
+	// even in browsers that don't focus <button> on click (Safari/Firefox on
+	// macOS). Skipped when focus is already inside the field.
 	function focusForPaste() {
 		if (!pasteable || !wrapEl) return;
 		if (wrapEl.contains(document.activeElement)) return;
@@ -570,12 +669,17 @@
 	}
 
 	$effect(() => {
-		if (!pasteable || !wrapEl) return;
+		// disabled and still-loading fields do not take pastes at all
+		if (!pasteable || typeof processAssets !== "function" || !wrapEl) return;
+		if (disabled || isLoading) return;
 		const el = wrapEl;
-		el.addEventListener("paste", handlePaste);
+		const unregister = register_paste_target({ el, handle: handlePaste });
+		// clicking still focuses the field: gives the `:focus-within` ring (the
+		// visible "paste lands here" affordance) and lets THIS field win the
+		// routing when several pasteable fields are mounted
 		el.addEventListener("click", focusForPaste, true);
 		return () => {
-			el.removeEventListener("paste", handlePaste);
+			unregister();
 			el.removeEventListener("click", focusForPaste, true);
 		};
 	});
@@ -764,7 +868,11 @@
 		{classLabelBox}
 		{classInputBox}
 		classInputBoxWrap={twMerge(
+			// the ring is the "paste lands here" affordance — only show it when
+			// paste actually works (same gating as the paste-target registration)
 			pasteable &&
+				typeof processAssets === "function" &&
+				!disabled &&
 				"focus-within:outline-2 focus-within:outline-offset-2 focus-within:outline-(--stuic-color-ring)",
 			classInputBoxWrap
 		)}

package/dist/components/Input/FieldAssets.svelte.d.ts

@@ -77,11 +77,22 @@ export interface Props extends InputWrapClassProps, Record<string, any> {
     ordered?: boolean;
     /**
      * Opt-in: allow pasting image/file data from the clipboard (Ctrl/Cmd-V) into
-     * the field. Focus-scoped — the paste is consumed only while the field (or a
-     * control inside it) holds focus; clicking anywhere in the field focuses it,
-     * so no Tab is needed. Routed through the same validation + upload path as
-     * drag and the file picker, so `accept`, `cardinality` and `processAssets`
-     * all apply. No-op unless `processAssets` is provided. Default `false`.
+     * the field. Routing: a paste is consumed while the field (or a control
+     * inside it) holds focus — clicking anywhere in the field focuses it. On
+     * top of that, a bare Ctrl/Cmd-V with no prior click is routed here — as
+     * long as this is the only pasteable + visible FieldAssets on the page —
+     * when focus is NOT in a text-entry element and is either unclaimed (fresh
+     * page, focus parked on <body>) or parked on a non-text control inside the
+     * SAME modal/dialog as the field (a drawer/modal takes focus on open, so
+     * <body> is never active there). Focus elsewhere is respected and never
+     * hijacked: not a text
+     * input/textarea/select/contenteditable (even one nested inside the field
+     * via the label/description/below snippets), not any other widget; with
+     * several pasteable fields mounted, click (focus) one to pick the
+     * destination. Disabled and `isLoading` fields take no pastes. Pasted
+     * files share the validation + upload path with drag and the file picker
+     * (`accept`, `cardinality` and `processAssets` all apply). No-op unless
+     * `processAssets` is provided. Default `false`.
      */
     pasteable?: boolean;
     classWrap?: string;

package/dist/components/Input/README.md

@@ -482,9 +482,22 @@ an upload progress indicator while processing).
 ### Paste from the clipboard (`pasteable`)
 
 Opt in with `pasteable` to let users paste image/file data from the clipboard (Ctrl/Cmd-V) —
-a screenshot, a copied image, etc. It is **focus-scoped**: a paste is consumed only while the
-field (or a control inside it) holds focus. Clicking anywhere in the field focuses it, so no
-Tab is needed, and a `:focus-within` ring on the input box signals the paste-ready state.
+a screenshot, a copied image, etc. Routing (via a single document-level listener shared by
+all mounted pasteable fields):
+
+- a paste is consumed while the field (or a control inside it) holds focus — clicking
+  anywhere in the field focuses it, and a `:focus-within` ring on the input box signals the
+  paste-ready state;
+- a paste with **no focus anywhere** (fresh page — focus parked on `<body>`) is routed to
+  the field as long as it is the _only_ pasteable (and visible) FieldAssets on the page, so
+  a bare Ctrl/Cmd-V works with no prior click;
+- focus elsewhere is respected: pasting while a text input, textarea, select,
+  contenteditable (even one nested _inside_ the field via the `label`/`description`/`below`
+  snippets) or any other widget holds focus is never hijacked. With several pasteable fields
+  mounted, an unfocused paste is ambiguous and ignored — click (focus) a field to pick the
+  destination;
+- `disabled` and `isLoading` fields take no pastes.
+
 Pasted files go through the same path as the picker and drag-and-drop, so `accept`,
 `cardinality` and `processAssets` all apply. No-op unless `processAssets` is provided.
 

package/dist/components/Modal/Modal.svelte

@@ -1,6 +1,15 @@
 <script lang="ts" module>
 	import type { Snippet } from "svelte";
 
+	/**
+	 * Return type of `Modal`'s `onEscape` handler.
+	 *
+	 * Resolve to `false` to VETO the Escape-close and keep the modal open; any
+	 * other value (including `undefined`) closes as before. May be async — the
+	 * modal stays open until the returned promise resolves.
+	 */
+	export type EscapeVeto = void | boolean | Promise<void | boolean>;
+
 	export interface Props {
 		visible?: boolean;
 		children: Snippet;
@@ -18,8 +27,13 @@
 		/** ID reference for aria-describedby */
 		describedby?: string;
 		el?: HTMLDivElement;
-		/** Called when Escape key is pressed while modal is open */
-		onEscape?: () => void;
+		/**
+		 * Called when Escape is pressed while the modal is open.
+		 * Return (or resolve to) `false` to VETO the close and keep the modal
+		 * open; any other value (incl. `undefined`) closes as before. May be
+		 * async — the modal stays open until the returned promise resolves.
+		 */
+		onEscape?: () => EscapeVeto;
 		/** Disable body scroll lock when modal is open */
 		noScrollLock?: boolean;
 		/** Disable close on backdrop / outside click */
@@ -82,8 +96,11 @@
 	}
 
 	function handlePreEscapeClose() {
-		onEscape?.();
-		// return undefined to allow close (preClose will set visible = false)
+		// Forward to ModalDialog.preEscapeClose, which closes only when the result
+		// is !== false and already awaits it — so an async veto is honoured and a
+		// `false` return keeps the modal open (preClose sets visible = false only
+		// when the close is actually allowed to proceed).
+		return onEscape?.();
 	}
 </script>
 

package/dist/components/Modal/Modal.svelte.d.ts

@@ -1,4 +1,12 @@
 import type { Snippet } from "svelte";
+/**
+ * Return type of `Modal`'s `onEscape` handler.
+ *
+ * Resolve to `false` to VETO the Escape-close and keep the modal open; any
+ * other value (including `undefined`) closes as before. May be async — the
+ * modal stays open until the returned promise resolves.
+ */
+export type EscapeVeto = void | boolean | Promise<void | boolean>;
 export interface Props {
     visible?: boolean;
     children: Snippet;
@@ -16,8 +24,13 @@ export interface Props {
     /** ID reference for aria-describedby */
     describedby?: string;
     el?: HTMLDivElement;
-    /** Called when Escape key is pressed while modal is open */
-    onEscape?: () => void;
+    /**
+     * Called when Escape is pressed while the modal is open.
+     * Return (or resolve to) `false` to VETO the close and keep the modal
+     * open; any other value (incl. `undefined`) closes as before. May be
+     * async — the modal stays open until the returned promise resolves.
+     */
+    onEscape?: () => EscapeVeto;
     /** Disable body scroll lock when modal is open */
     noScrollLock?: boolean;
     /** Disable close on backdrop / outside click */

package/dist/components/Modal/README.md

@@ -4,19 +4,19 @@ A styled modal dialog with optional header and footer sections. Built on top of
 
 ## Props
 
-| Prop           | Type             | Default | Description                        |
-| -------------- | ---------------- | ------- | ---------------------------------- |
-| `visible`      | `boolean`        | `false` | Controls visibility (bindable)     |
-| `onEscape`     | `() => void`     | -       | Callback on Escape key             |
-| `noScrollLock` | `boolean`        | `false` | Disable body scroll lock           |
-| `classInner`   | `string`         | -       | CSS for inner width container      |
-| `class`        | `string`         | -       | CSS for modal box                  |
-| `classHeader`  | `string`         | -       | CSS for header section             |
-| `classMain`    | `string`         | -       | CSS for main content               |
-| `classFooter`  | `string`         | -       | CSS for footer section             |
-| `labelledby`   | `string`         | -       | ARIA labelledby ID                 |
-| `describedby`  | `string`         | -       | ARIA describedby ID                |
-| `el`           | `HTMLDivElement` | -       | Modal element reference (bindable) |
+| Prop           | Type                                                | Default | Description                                                                                                                                          |
+| -------------- | --------------------------------------------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `visible`      | `boolean`                                           | `false` | Controls visibility (bindable)                                                                                                                       |
+| `onEscape`     | `() => void \| boolean \| Promise<void \| boolean>` | -       | Escape handler. Return/resolve `false` to **veto** the close and keep the modal open (see below); anything else (incl. `undefined`) closes as before |
+| `noScrollLock` | `boolean`                                           | `false` | Disable body scroll lock                                                                                                                             |
+| `classInner`   | `string`                                            | -       | CSS for inner width container                                                                                                                        |
+| `class`        | `string`                                            | -       | CSS for modal box                                                                                                                                    |
+| `classHeader`  | `string`                                            | -       | CSS for header section                                                                                                                               |
+| `classMain`    | `string`                                            | -       | CSS for main content                                                                                                                                 |
+| `classFooter`  | `string`                                            | -       | CSS for footer section                                                                                                                               |
+| `labelledby`   | `string`                                            | -       | ARIA labelledby ID                                                                                                                                   |
+| `describedby`  | `string`                                            | -       | ARIA describedby ID                                                                                                                                  |
+| `el`           | `HTMLDivElement`                                    | -       | Modal element reference (bindable)                                                                                                                   |
 
 ## Snippets
 
@@ -92,6 +92,33 @@ A styled modal dialog with optional header and footer sections. Built on top of
 </Modal>
 ```
 
+### Vetoable Escape close (confirm before dismiss)
+
+`onEscape` can **keep the modal open** by returning (or resolving to) `false` —
+useful for an "unsaved changes" guard. It may be async: the modal stays open
+until the returned promise resolves, so you can await a confirm dialog.
+
+```svelte
+<script lang="ts">
+	let modal: Modal;
+	let dirty = $state(false);
+
+	// Return false to VETO the close and keep the modal open.
+	async function requestClose(): Promise<boolean> {
+		if (dirty && !(await confirmDiscard())) return false; // veto — stay open
+		modal.close();
+		return true;
+	}
+</script>
+
+<Modal bind:this={modal} onEscape={requestClose} noClickOutsideClose>
+	<div class="p-6">Edit form with unsaved changes…</div>
+</Modal>
+```
+
+> Only the Escape path is vetoable. The Cancel button and programmatic
+> `close()` are yours to gate — run the same confirm before calling `close()`.
+
 ### Custom Sizing
 
 ```svelte

package/dist/components/Modal/index.d.ts

@@ -1 +1 @@
-export { default as Modal, type Props as ModalProps } from "./Modal.svelte";
+export { default as Modal, type Props as ModalProps, type EscapeVeto, } from "./Modal.svelte";

package/dist/components/Modal/index.js

@@ -1 +1 @@
-export { default as Modal } from "./Modal.svelte";
+export { default as Modal, } from "./Modal.svelte";

package/dist/components/ModalDialog/ModalDialog.fixture.svelte

@@ -5,7 +5,10 @@
 	// fixture holds the `bind:this` ref and exposes an opener button that calls
 	// `.open()`; ModalDialog props are forwarded through `...rest`. The default
 	// content (an "inside" button) is the required `children` snippet — it also
-	// gives the focus trap a real focusable element to auto-focus.
+	// gives the focus trap a real focusable element to auto-focus. A second
+	// "programmatic-close" button (kept INSIDE the dialog so it stays clickable
+	// while showModal() makes the rest of the page inert) calls `.close()` so a
+	// test can assert the programmatic close path is NOT gated by the Escape veto.
 	import ModalDialog from "./ModalDialog.svelte";
 
 	let dialog = $state<ModalDialog>();
@@ -16,4 +19,7 @@
 
 <ModalDialog bind:this={dialog} {...rest}>
 	<button data-testid="inside">Inside</button>
+	<button data-testid="programmatic-close" onclick={() => dialog?.close()}>
+		close
+	</button>
 </ModalDialog>

package/dist/components/ModalDialog/ModalDialog.svelte

@@ -58,6 +58,7 @@
 	let box = $state<HTMLDivElement>()!;
 	let _opener: undefined | null | HTMLElement = $state();
 	let _isClosing = false;
+	let _isEscaping = false;
 
 	export function open(openerOrEvent?: null | HTMLElement | MouseEvent) {
 		if (visible) return; // Already open
@@ -143,13 +144,22 @@
 			// do not allow additional onkeydown listeners on this dialog
 			e.stopImmediatePropagation();
 
-			if (!noEscapeClose) {
+			// `noEscapeClose` short-circuits (unchanged). `_isEscaping` is a
+			// re-entrancy latch: with an async `preEscapeClose` veto, a rapid
+			// second Escape would otherwise invoke the hook again and stack a
+			// duplicate confirm. It resets in `finally`, so a vetoed close can be
+			// retried on a subsequent Escape.
+			if (noEscapeClose || _isEscaping) return;
+			_isEscaping = true;
+			try {
 				// explicit false prevents close
-				let allowed = await preEscapeClose?.();
+				const allowed = await preEscapeClose?.();
 				if (allowed !== false) {
 					// `preClose` will be handled next
 					close();
 				}
+			} finally {
+				_isEscaping = false;
 			}
 		}
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@marianmeres/stuic",
-	"version": "3.140.0",
+	"version": "3.142.0",
 	"packageManager": "pnpm@11.5.0",
 	"scripts": {
 		"dev": "vite dev",
@@ -179,7 +179,7 @@
 	"dependencies": {
 		"@marianmeres/clog": "^3.21.0",
 		"@marianmeres/countries": "^1.0.1",
-		"@marianmeres/cron": "^2.0.1",
+		"@marianmeres/cron-parser": "^1.0.1",
 		"@marianmeres/design-tokens": "^1.12.0",
 		"@marianmeres/icons-fns": "^5.0.0",
 		"@marianmeres/item-collection": "^1.4.2",