@lostgradient/cinder 0.2.0 → 0.3.0

package/dist/_internal/overlay.d.ts

@@ -60,15 +60,37 @@ export type OverlayLayer = keyof typeof Z_LAYERS;
 export declare function useHydrated(): {
     value: boolean;
 };
+/**
+ * Stack of ESC handlers. Top-most overlay handles ESC; lower overlays ignore
+ * the event. Each overlay registers a handler on open and unregisters on close.
+ *
+ * The stack lives in module scope so all Cinder overlays share it. It persists
+ * for the lifetime of the JS module — under bun:test that means it is shared
+ * across every test in a file, so suites that leave handlers registered must
+ * call `_resetEscapeStack()` between cases to avoid leaking state. In
+ * production this is fine (a real app has at most a handful of stacked overlays
+ * at once). It is a plain LIFO stack: each `pushEscapeHandler` call appends one
+ * entry and returns a one-shot `release` token that removes that entry's most
+ * recent occurrence. Overlays push exactly once per open and release via the
+ * returned token, so duplicates don't arise in practice; releasing a token
+ * twice (or releasing a handler already gone) is a no-op.
+ */
+/**
+ * An escape-stack handler. Receives the originating `KeyboardEvent` so a
+ * handler that owns the keystroke (e.g. a nested interactive popup closing on
+ * Escape) can call `event.preventDefault()` to stop the key from also reaching
+ * the page's default action. Most overlays ignore the argument and just close.
+ */
+type EscapeHandler = (event: KeyboardEvent) => void;
 /**
  * Register a handler to be called when ESC is pressed and this overlay is at
- * the top of the stack. Returns a `release` function the overlay must call
- * on close.
+ * the top of the stack. The handler receives the originating `KeyboardEvent`.
+ * Returns a `release` function the overlay must call on close.
  *
  * The first handler pushed installs the global keydown listener; the last
  * handler popped removes it.
  */
-export declare function pushEscapeHandler(handler: () => void): () => void;
+export declare function pushEscapeHandler(handler: EscapeHandler): () => void;
 /**
  * Test-only: clear the escape stack. Useful between tests to ensure a fresh
  * starting state. Not part of the public overlay API.
@@ -98,3 +120,4 @@ export declare function _resetScrollLock(): void;
  * element) when null.
  */
 export declare function captureFocus(): HTMLElement | null;
+export {};

package/dist/_internal/toast-context.d.ts

@@ -34,6 +34,12 @@ export type ToastOptions = {
      * and variant, never by the icon alone.
      */
     icon?: Snippet;
+    /**
+     * When true, renders a per-variant default icon before the message. Defaults
+     * to false. Has no effect when a custom icon snippet is provided via the icon
+     * prop.
+     */
+    showIcon?: boolean;
     /**
      * Optional action paired with the message. Renders a button after the
      * message text and invokes `onAction` when clicked. The toast is dismissed
@@ -53,6 +59,8 @@ export type ToastItem = {
     variant: ToastVariant;
     duration: number;
     dismissible: boolean;
+    /** Normalized from ToastOptions.showIcon; defaults to false. */
+    showIcon: boolean;
     icon?: Snippet;
     action?: {
         label: string;

package/dist/_internal/tree-context.d.ts

@@ -1,4 +1,5 @@
 import type { TreeSelectionState } from '../components/tree/tree-selection.ts';
+import type { TreeDragController } from './tree-drag-controller.svelte.ts';
 import type { TreeNodeRegistration } from './tree-registry.svelte.ts';
 type TreeSelectionMode = 'none' | 'single' | 'multiple';
 type TreeSelectionBehavior = 'independent' | 'cascade';
@@ -25,9 +26,19 @@ export type TreeContext = {
     readonly selectedIds: readonly string[];
     /** Reactive getter — reading inside $derived registers cross-component dependency. */
     readonly focusedId: string | null;
+    readonly filtering: boolean;
+    readonly filterValue: string;
+    readonly hasRegisteredItems: boolean;
+    readonly expandableBranchCount: number;
+    readonly hasExpandedItems: boolean;
+    readonly dragController: TreeDragController | null;
+    readonly dragInstructionsId: string;
     isExpanded(id: string): boolean;
     isSelected(id: string): boolean;
     isFocused(id: string): boolean;
+    isVisible(id: string): boolean;
+    hasVisibleDescendant(id: string): boolean;
+    matchesFilter(label: string, id: string): boolean;
     checkboxSelectionActive(): boolean;
     selectionStateFor(id: string): TreeItemSelectionState;
     toggleSelectionScope(id: string): void;
@@ -36,9 +47,16 @@ export type TreeContext = {
     selectionTargetsFor(id: string): readonly string[];
     selectionTargetsForChildren(parentId: string | null, includeDescendants: boolean): readonly string[];
     setExpanded(id: string, next: boolean): void;
+    expandAll(): Promise<void>;
+    collapseAll(): void;
+    expandOneLevel(): void;
+    focusItem(id: string): void;
+    expandToItem(id: string): Promise<void>;
+    scrollToRow(id: string, options?: ScrollIntoViewOptions): void;
     toggleSelected(id: string, event: KeyboardEvent | MouseEvent | null): void;
     register(node: TreeNodeRegistration): () => void;
     focusVisibleDelta(currentId: string, delta: number): void;
+    canFocusVisibleDelta(currentId: string, delta: number): boolean;
     focusFirstVisible(): void;
     focusLastVisible(): void;
     focusParent(currentId: string): void;

package/dist/_internal/tree-data.d.ts

@@ -0,0 +1,22 @@
+export type TreeDataItem = {
+    id: string;
+    label: string;
+    disabled?: boolean;
+    children?: readonly TreeDataItem[];
+};
+export type FlattenedTreeDataItem = {
+    id: string;
+    label: string;
+    disabled: boolean;
+    parentId: string | null;
+    level: number;
+    branch: boolean;
+    index: number;
+    posInSet: number;
+    setSize: number;
+    ancestorIds: readonly string[];
+};
+export type TreeDataFilterPredicate = (item: FlattenedTreeDataItem) => boolean;
+export declare function flattenTreeDataItems(items: readonly TreeDataItem[]): FlattenedTreeDataItem[];
+export declare function visibleTreeDataItems(flattenedItems: readonly FlattenedTreeDataItem[], expandedIds: readonly string[], filterPredicate?: TreeDataFilterPredicate): FlattenedTreeDataItem[];
+export declare function descendantTreeDataIds(flattenedItems: readonly FlattenedTreeDataItem[], parentId: string): string[];

package/dist/_internal/tree-drag-controller.svelte.d.ts

@@ -0,0 +1,47 @@
+import type { TreeNodeRegistration } from './tree-registry.svelte.ts';
+export type TreeDropPosition = 'before' | 'after' | 'child';
+export type TreeDropTarget = {
+    id: string;
+    position: TreeDropPosition;
+};
+export type TreeReorderTarget = TreeDropTarget & {
+    fromParentId: string | null;
+    toParentId: string | null;
+};
+export type TreeDragSource = 'keyboard' | 'pointer';
+export type TreeMoveNode = {
+    id: string;
+    parentId: string | null;
+};
+type TreeDragControllerOptions = {
+    getVisibleIds: () => readonly string[];
+    getNode: (id: string) => TreeNodeRegistration | undefined;
+    getParentId: (id: string) => string | null | undefined;
+    isBranch: (id: string) => boolean;
+    focus: (id: string) => void;
+    announce: (message: string) => void;
+    commit: (draggedId: string, target: TreeReorderTarget) => void;
+};
+export declare class TreeDragController {
+    #private;
+    phase: "idle" | "dragging";
+    draggedId: string | null;
+    dropTarget: TreeDropTarget | null;
+    dragSource: TreeDragSource | null;
+    constructor(options: TreeDragControllerOptions);
+    get dragging(): boolean;
+    get pointerDragging(): boolean;
+    isDragging(id: string): boolean;
+    isDropTarget(id: string, position?: TreeDropPosition): boolean;
+    lift(id: string, source: TreeDragSource): void;
+    moveBy(delta: 1 | -1): void;
+    moveToEdge(edge: 'first' | 'last'): void;
+    moveIntoPreviousBranch(): void;
+    moveOut(): void;
+    setDropTarget(target: TreeDropTarget | null): void;
+    drop(): void;
+    cancel(): void;
+    targetFromPointer(pointerY: number, element: HTMLElement): TreeDropTarget | null;
+}
+export declare function moveTreeNode<Node extends TreeMoveNode>(nodes: Node[], draggedId: string, target: TreeDropTarget): Node[];
+export {};

package/dist/_internal/tree-registry.svelte.d.ts

@@ -9,10 +9,18 @@ export type TreeNodeRegistration = {
     readonly disabled: boolean;
     selectionScopeIds?: () => readonly string[] | undefined;
     isBranch: () => boolean;
+    bulkExpandable?: () => boolean;
     label: () => string;
     /** DOM-focus the outer role="treeitem" element. */
     focus: () => void;
 };
+export type TreeVisibilityCandidate = {
+    id: string;
+    label: string;
+    parentId: string | null;
+    level: number;
+};
+export type TreeVisibilityPredicate = (candidate: TreeVisibilityCandidate) => boolean;
 /**
  * Reactive registry for tree nodes. Tracks registration order (DOM mount
  * order), parent/child relationships, and computes a flat visible-order list
@@ -22,22 +30,30 @@ export type TreeNodeRegistration = {
  */
 export declare class TreeRegistry {
     #private;
+    get size(): number;
     register(node: TreeNodeRegistration): () => void;
     /**
      * Returns the flat list of node ids in DFS visible order, respecting the
-     * current expansion state. Collapsed subtrees are excluded entirely.
+     * current expansion state. Collapsed subtrees are excluded entirely unless a
+     * filter predicate is supplied, in which case matching nodes and their
+     * ancestors are retained.
      */
-    getVisible(expandedIds: readonly string[]): string[];
+    getVisible(expandedIds: readonly string[], visibilityPredicate?: TreeVisibilityPredicate): string[];
     getNode(id: string): TreeNodeRegistration | undefined;
     parentOf(id: string): string | null | undefined;
     firstChildOf(id: string): string | undefined;
     childrenOf(parentId: string | null): string[];
     descendantsOf(parentId: string): string[];
+    getAllBranchIds(options?: {
+        bulkOnly?: boolean;
+    }): string[];
+    isBulkExpandableBranch(id: string): boolean;
+    ancestorsOf(id: string): string[];
     siblingsOf(id: string): string[];
     /**
      * Returns the next visible item id whose label starts with `prefix`
      * (case-insensitive), searching forward from `currentId` and wrapping.
      * Returns `undefined` when no match found.
      */
-    typeaheadMatch(prefix: string, currentId: string, expandedIds: readonly string[]): string | undefined;
+    typeaheadMatch(prefix: string, currentId: string, expandedIds: readonly string[], visibilityPredicate?: TreeVisibilityPredicate): string | undefined;
 }

package/dist/_internal/use-virtualizer.svelte.d.ts

@@ -0,0 +1,21 @@
+import { type ScrollToOptions, type VirtualItem } from '@tanstack/virtual-core';
+import type { Attachment } from 'svelte/attachments';
+export type TreeVirtualizerOptions = {
+    getScrollElement: () => HTMLElement | null;
+    getCount: () => number;
+    getItemKey: (index: number) => string | number;
+    getEstimatedSize: () => number;
+    getOverscan: () => number;
+    getInitialHeight: () => number;
+};
+export declare class TreeVirtualizer {
+    #private;
+    readonly options: TreeVirtualizerOptions;
+    constructor(options: TreeVirtualizerOptions);
+    get virtualItems(): VirtualItem[];
+    get totalSize(): number;
+    setScrollElement(element: HTMLElement | null): void;
+    scrollElement: Attachment<HTMLElement>;
+    measureElement: Attachment<HTMLElement>;
+    scrollToIndex(index: number, options?: ScrollToOptions): void;
+}

package/dist/_internal/virtual-item.d.ts

@@ -0,0 +1 @@
+export type { VirtualItem } from '@tanstack/virtual-core';

package/dist/components/_timeline-item/index.d.ts

@@ -0,0 +1,4 @@
+import TimelineItem from './timeline-item.svelte';
+export default TimelineItem;
+export type { TimelineItemProps } from './timeline-item.types.ts';
+export { TimelineItem };

package/dist/components/_tree-expand-all/index.d.ts

@@ -0,0 +1,4 @@
+import TreeExpandAll from './tree-expand-all.svelte';
+export default TreeExpandAll;
+export type { TreeExpandAllProps } from './tree-expand-all.types.ts';
+export { TreeExpandAll };

package/dist/components/_tree-expand-all/tree-expand-all.svelte.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @cinder
+ * @category data-display
+ * @status stable
+ * @purpose Context control for expanding or collapsing all registered static Tree branches.
+ * @tag tree
+ * @tag expansion
+ * @useWhen Adding expand-all and collapse-all controls to a Tree selectionControls snippet.
+ * @useWhen Expanding registered static Tree branches without placing controls inside role="tree".
+ * @avoidWhen Rendering outside a Tree component — it requires Tree selectionControls context.
+ * @avoidWhen Triggering async lazy loading for every branch; bulk expansion skips loadChildren branches.
+ * @related tree, tree-item
+ */
+export type { TreeExpandAllProps } from './tree-expand-all.types.ts';
+import type { TreeExpandAllProps } from './tree-expand-all.types.ts';
+declare const TreeExpandAll: import("svelte").Component<TreeExpandAllProps, {}, "">;
+type TreeExpandAll = ReturnType<typeof TreeExpandAll>;
+export default TreeExpandAll;

package/dist/components/_tree-expand-all/tree-expand-all.types.d.ts

@@ -0,0 +1,15 @@
+/** Props for the TreeExpandAll component. */
+export type TreeExpandAllProps = {
+    /** Text label shown before the action buttons. */
+    label?: string;
+    /** Label for the full expand action. */
+    expandAllLabel?: string;
+    /** Label for the one-level expand action shown on large trees. */
+    expandOneLevelLabel?: string;
+    /** Label for the collapse-all action. */
+    collapseAllLabel?: string;
+    /** Branch count above which a one-level expand safety action is shown. */
+    safetyThreshold?: number;
+    /** Additional class merged with `.cinder-tree-expand-all`. */
+    class?: string;
+};

package/dist/components/_visually-hidden-live-region.svelte.d.ts

@@ -32,6 +32,15 @@
 export type LiveRegionPriority = 'polite' | 'assertive';
 type $$ComponentProps = {
     message?: string;
+    /**
+     * Bump this (monotonically) to force a re-announcement of an identical
+     * `message`. In Svelte 5, assigning the same string to a `$state` is a no-op,
+     * so a consumer that announces the same text twice in a row (e.g. adding the
+     * same tag again) would not re-run this component's effect. Reading the
+     * sequence inside the effect registers it as a dependency, so incrementing it
+     * — even with `message` unchanged — re-fires the blank-then-set dance.
+     */
+    announcementSequence?: number;
     priority?: LiveRegionPriority;
     class?: string;
 };

package/dist/components/access-gate/access-gate-inline.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { Snippet } from 'svelte';
+import type { SvelteHTMLElements } from 'svelte/elements';
+export type AccessGateInlineProps = Omit<SvelteHTMLElements['div'], 'aria-describedby' | 'aria-labelledby' | 'class' | 'role'> & {
+    /** Additional class names appended to the inline denied wrapper. */
+    class?: string | undefined;
+    /** Human-readable explanation for why the action is unavailable. */
+    reason: string;
+    /** Control or controls kept visible while denied. */
+    children?: Snippet;
+};
+declare const AccessGateInline: import("svelte").Component<AccessGateInlineProps, {}, "">;
+type AccessGateInline = ReturnType<typeof AccessGateInline>;
+export default AccessGateInline;

package/dist/components/access-gate/access-gate.css

@@ -0,0 +1,129 @@
+@layer cinder.tokens, cinder.foundation, cinder.components, cinder.utilities;
+@layer cinder.components {
+  .cinder-access-gate {
+    color: var(--cinder-text);
+  }
+
+  .cinder-access-gate__passthrough {
+    display: contents;
+  }
+
+  .cinder-access-gate[data-cinder-variant='inline'] {
+    display: inline-flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: var(--cinder-space-2);
+    max-inline-size: 100%;
+    vertical-align: middle;
+  }
+
+  .cinder-access-gate__inline-content {
+    display: inline-flex;
+    min-inline-size: 0;
+  }
+
+  .cinder-access-gate__inline-content [data-cinder-access-gate-control] {
+    color: var(--cinder-text-disabled);
+    cursor: not-allowed;
+    opacity: 0.6;
+  }
+
+  .cinder-access-gate__inline-reason {
+    display: inline-flex;
+    flex: 1 1 auto;
+    align-items: center;
+    gap: var(--cinder-space-1);
+    min-inline-size: 0;
+    color: var(--cinder-text-muted);
+    font-size: var(--cinder-text-xs);
+    line-height: var(--cinder-leading-snug);
+  }
+
+  .cinder-access-gate__inline-reason > svg {
+    flex: 0 0 auto;
+  }
+
+  .cinder-access-gate__inline-reason > span {
+    overflow-wrap: anywhere;
+  }
+
+  .cinder-access-gate[data-cinder-variant='section'] {
+    display: grid;
+    grid-template-columns: auto minmax(0, 1fr);
+    gap: var(--cinder-space-3);
+    align-items: start;
+    inline-size: 100%;
+    padding-block: var(--cinder-space-6);
+    padding-inline: var(--cinder-space-5);
+    border: 1px dashed var(--cinder-border);
+    border-radius: var(--cinder-radius-md);
+    background: var(--cinder-surface);
+  }
+
+  .cinder-access-gate__section-icon {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    inline-size: 2rem;
+    block-size: 2rem;
+    border-radius: var(--cinder-radius-md);
+    background: var(--cinder-surface-raised);
+    color: var(--cinder-text-muted);
+  }
+
+  .cinder-access-gate__section-copy {
+    display: grid;
+    gap: var(--cinder-space-1);
+    min-inline-size: 0;
+  }
+
+  .cinder-access-gate__section-title {
+    color: var(--cinder-text);
+    font-size: var(--cinder-text-base);
+    font-weight: var(--cinder-font-semibold);
+    line-height: var(--cinder-leading-snug);
+  }
+
+  .cinder-access-gate__section-reason {
+    color: var(--cinder-text-muted);
+    font-size: var(--cinder-text-sm);
+    line-height: var(--cinder-leading-normal);
+  }
+
+  .cinder-access-gate__requirement {
+    display: flex;
+    flex-wrap: wrap;
+    gap: var(--cinder-space-1) var(--cinder-space-2);
+    align-items: baseline;
+    margin-block-start: var(--cinder-space-2);
+    color: var(--cinder-text-muted);
+    font-size: var(--cinder-text-xs);
+    line-height: var(--cinder-leading-snug);
+  }
+
+  .cinder-access-gate__requirement-label {
+    font-weight: var(--cinder-font-medium);
+  }
+
+  .cinder-access-gate__requirement-value {
+    padding-block: var(--cinder-space-0-5);
+    padding-inline: var(--cinder-space-1);
+    border: 1px solid var(--cinder-border);
+    border-radius: var(--cinder-radius-sm);
+    background: var(--cinder-surface-raised);
+    color: var(--cinder-text);
+    font-family: var(--cinder-font-mono);
+    font-size: 0.92em;
+  }
+
+  @media (forced-colors: active) {
+    .cinder-access-gate[data-cinder-variant='section'] {
+      border-color: CanvasText;
+    }
+
+    .cinder-access-gate__section-icon,
+    .cinder-access-gate__requirement-value {
+      border: 1px solid CanvasText;
+    }
+  }
+}

package/dist/components/access-gate/access-gate.schema.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/components/access-gate/access-gate.schema.ts
+var schema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  properties: {
+    granted: {
+      type: "boolean",
+      description: "Whether the consumer-authorized action or section is available."
+    },
+    variant: {
+      enum: ["inline", "section"],
+      description: "Presentation mode.",
+      default: "inline"
+    },
+    reason: {
+      type: "string",
+      description: "Human-readable explanation shown to users and wired to assistive technology."
+    },
+    requirement: {
+      type: "string",
+      description: "Named scope, permission, or policy requirement shown in the section placeholder."
+    },
+    class: {
+      type: "string",
+      description: "Custom class merged with the denied-state wrapper or section placeholder."
+    }
+  },
+  additionalProperties: false,
+  required: ["granted", "reason"],
+  metadata: {
+    unsupportedProps: [
+      {
+        name: "children",
+        reason: "function-or-snippet",
+        description: "Gated content. Rendered untouched when access is granted."
+      }
+    ]
+  }
+};
+var access_gate_schema_default = schema;
+export {
+  access_gate_schema_default as default
+};
+
+//# debugId=DA20DB3E51111EC064756E2164756E21

package/dist/components/access-gate/access-gate.svelte.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @cinder
+ * @category feedback
+ * @status alpha
+ * @purpose Authorization-scope gate that keeps unavailable actions visible with an accessible reason or replaces locked sections with a scope-required placeholder.
+ * @tag feedback
+ * @tag authorization
+ * @tag permission
+ * @useWhen Showing a mutating action that the current user cannot activate because an application authorization scope is missing.
+ * @useWhen Replacing a panel, tab, or administrative section with a lock state that names the missing scope or permission.
+ * @avoidWhen Checking browser permissions, media capabilities, or feature support — use capability-gate instead.
+ * @avoidWhen Resolving roles, scopes, or policies — compute granted in application code and pass the boolean in.
+ * @related capability-gate, button, callout, empty-state
+ * @a11yNote Denied inline gates render content inert before hydration, then disable controls, remove them from sequential focus, and wire the reason through aria-describedby.
+ */
+export type { AccessGateProps, AccessGateVariant } from './access-gate.types.ts';
+import type { AccessGateProps } from './access-gate.types.ts';
+declare const AccessGate: import("svelte").Component<AccessGateProps, {}, "">;
+type AccessGate = ReturnType<typeof AccessGate>;
+export default AccessGate;

package/dist/components/access-gate/access-gate.types.d.ts

@@ -0,0 +1,40 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+/** Presentation mode for the access gate. */
+export type AccessGateVariant = 'inline' | 'section';
+/** Props for the AccessGate component. */
+export type AccessGateProps = Omit<HTMLAttributes<HTMLElement>, 'aria-describedby' | 'aria-labelledby' | 'children' | 'class' | 'role'> & {
+    /** Whether the consumer-authorized action or section is available. */
+    granted: boolean;
+    /**
+     * Presentation mode.
+     * @default "inline"
+     */
+    variant?: AccessGateVariant;
+    /** Human-readable explanation shown to users and wired to assistive technology. */
+    reason: string;
+    /** Named scope, permission, or policy requirement shown in the section placeholder. */
+    requirement?: string;
+    /** Gated content. Rendered untouched when access is granted. */
+    children?: Snippet;
+    /** Custom class merged with the denied-state wrapper or section placeholder. */
+    class?: string;
+};
+/** Cinder-specific props for AccessGate, used by the schema generator. */
+export interface AccessGateSchemaProps {
+    /** Whether the consumer-authorized action or section is available. */
+    granted: boolean;
+    /**
+     * Presentation mode.
+     * @default "inline"
+     */
+    variant?: AccessGateVariant;
+    /** Human-readable explanation shown to users and wired to assistive technology. */
+    reason: string;
+    /** Named scope, permission, or policy requirement shown in the section placeholder. */
+    requirement?: string;
+    /** Gated content. Rendered untouched when access is granted. */
+    children?: Snippet;
+    /** Custom class merged with the denied-state wrapper or section placeholder. */
+    class?: string;
+}

package/dist/components/access-gate/access-gate.variables.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/components/access-gate/access-gate.variables.ts
+var variables = [];
+var access_gate_variables_default = variables;
+export {
+  access_gate_variables_default as default
+};
+
+//# debugId=BF7C9637796B04F564756E2164756E21

package/dist/components/access-gate/index.d.ts

@@ -0,0 +1,5 @@
+import './access-gate.css';
+import AccessGate from './access-gate.svelte';
+export default AccessGate;
+export type { AccessGateProps, AccessGateVariant } from './access-gate.types.ts';
+export { AccessGate };