@happyvertical/smrt-svelte 0.30.0

package/dist/components/workspace/tools-dock/use-tools-dock.js

@@ -0,0 +1,50 @@
+/**
+ * useToolsDock - read the {@link ToolsDockApi} from Svelte context.
+ *
+ * Tools and arbitrary descendants of `<ToolsDock>` use this to obtain the
+ * dock instance that owns them — open/close themselves, push events through
+ * the typed bus, react to the current `context`, etc.
+ *
+ * Throws a clear error if called outside a `<ToolsDock>` provider tree so
+ * misuse fails loudly during development rather than producing silent nulls.
+ *
+ * The returned `dock.context` is the default {@link ToolsDockContext} shape.
+ * For typed access from within a tool body, the recommended pattern is to
+ * type the component's own `context` prop locally — see the JSDoc on
+ * {@link ToolDef.component} for an example. (`ToolDef` deliberately erases
+ * its context generic at registration time so the dock can store tools as
+ * a single homogeneous `ToolDef[]`.)
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ *   import { useToolsDock } from '@happyvertical/smrt-svelte/workspace';
+ *   const dock = useToolsDock();
+ * </script>
+ *
+ * <button type="button" onclick={() => dock.close()}>Close</button>
+ * ```
+ */
+import { getContext } from 'svelte';
+import { TOOLS_DOCK_KEY } from './define-tools-dock.svelte.js';
+/**
+ * Retrieve the {@link ToolsDockApi} from Svelte context.
+ *
+ * @throws Error when called outside a `<ToolsDock>` provider tree
+ */
+export function useToolsDock() {
+    const dock = getContext(TOOLS_DOCK_KEY);
+    if (!dock) {
+        throw new Error('[useToolsDock] No ToolsDock instance found on Svelte context. ' +
+            'Wrap your tree in <ToolsDock dock={defineToolsDock(...)} /> first.');
+    }
+    return dock;
+}
+/**
+ * Non-throwing variant — returns `null` outside a provider. Useful for
+ * optional integrations where a tool should degrade gracefully if not
+ * embedded inside a `<ToolsDock>`.
+ */
+export function tryUseToolsDock() {
+    return getContext(TOOLS_DOCK_KEY) ?? null;
+}

package/dist/components/workspace/types.d.ts

@@ -0,0 +1,372 @@
+/**
+ * Shared types for the workspace shell primitives.
+ *
+ * See @happyvertical/smrt#1226 (epic) and #1227 / #1228 / #1229 (implementers).
+ */
+import type { Component } from 'svelte';
+export interface NavItem {
+    href: string;
+    label: string;
+    icon?: string;
+    description?: string;
+    exact?: boolean;
+    defaultExpanded?: boolean;
+    badge?: number | string | null;
+    children?: NavItem[];
+}
+export interface BreadcrumbItem {
+    href?: string;
+    label: string;
+}
+/**
+ * Configuration for a single role in a multi-role admin shell. The role
+ * determines which navigation sections are shown, the display label, and
+ * an optional color identifier consumers can use to theme the shell.
+ *
+ * Role IDs are arbitrary strings — the framework doesn't know about specific
+ * roles. Consumers pick whatever set fits their app (e.g. 'super', 'admin',
+ * 'tenant-owner', 'editor').
+ *
+ * See `RoleShell` for the renderer that consumes this config and
+ * `happyvertical/smrt#1226` (Phase 4b) for design context.
+ */
+export interface RoleConfig {
+    /** Stable role identifier. */
+    id: string;
+    /** Display label (e.g. "Super Admin"). */
+    label: string;
+    /** Optional subtitle / description. */
+    description?: string;
+    /** Optional icon string/glyph for the role's header area. */
+    icon?: string;
+    /**
+     * Optional color identifier. Rendered as a CSS custom property
+     * `--smrt-role-color: <value>` on the shell root so consumer CSS can
+     * theme child components. Pick a semantic name your design system
+     * understands (e.g. 'blue', 'success', 'primary').
+     */
+    color?: string;
+    /** Navigation sections shown for this role. Same shape as NavItem[]. */
+    sections: NavItem[];
+}
+export interface ToolDef {
+    id: string;
+    label: string;
+    /**
+     * Single-character glyph or emoji rendered in the rail layout when no
+     * `iconComponent` is provided. Defaults to the uppercased first character
+     * of `label` when both are omitted.
+     *
+     * Note: ambiguous in dense docks (e.g. "Chat" and "Claim Audit" both
+     * collapse to "C"). Provide `iconComponent` for production docks — see
+     * the `iconComponent` field below.
+     */
+    icon?: string;
+    /**
+     * Component rendered in the rail layout (and as a leading glyph in the
+     * topbar layout) for this tool. Takes precedence over `icon`. Matches
+     * the pattern used by `NavTree` for per-item icons — pass the icon
+     * component from your library of choice (lucide-svelte etc.) directly,
+     * or a thin `.svelte` wrapper around it.
+     *
+     * The component is rendered with no props (`<IconComponent />`); if your
+     * icon library needs sizing, wrap it in a thin `.svelte` component that
+     * hard-codes the dimensions you want (typically ~18px to match
+     * `.tools-dock__rail-glyph`).
+     *
+     * @example
+     * ```ts
+     * import MessageSquare from 'lucide-svelte/icons/message-square';
+     * import ChatPanel from './ChatPanel.svelte';
+     *
+     * const tool: ToolDef = {
+     *   id: 'chat',
+     *   label: 'Chat',
+     *   iconComponent: MessageSquare,
+     *   component: ChatPanel,
+     * };
+     * ```
+     */
+    iconComponent?: Component;
+    /**
+     * Panel component rendered when this tool is active. Receives the dock's
+     * current `context` and the dock API.
+     *
+     * Tools that want typed access to `context.data` / `context.actions`
+     * should locally type their own props inside the component, e.g.
+     *
+     * ```svelte
+     * <script lang="ts">
+     *   import type { ToolsDockApi, ToolsDockContext } from
+     *     '@happyvertical/smrt-svelte/workspace';
+     *
+     *   interface MyData { siteSlug: string; contentId: string }
+     *   interface MyActions { triggerSave(): void }
+     *
+     *   let { context, dock }: {
+     *     context: ToolsDockContext<MyData, MyActions> | null;
+     *     dock: ToolsDockApi;
+     *   } = $props();
+     * </script>
+     * ```
+     *
+     * The dock erases tool-specific types at registration (tools are stored
+     * as a homogeneous `ToolDef[]`), so the props type is intentionally
+     * `Component<any>`. Svelte component props are checked contravariantly,
+     * which means a hard-coded `Component<{ context: ToolsDockContext | null; ... }>`
+     * slot would reject any component declaring a narrower
+     * `context: ToolsDockContext<MyData, MyActions> | null` prop — defeating
+     * the point of letting consumers type the prop locally. Erasing here
+     * means the per-component prop annotation shown above compiles without
+     * a registration-site cast.
+     *
+     * A previous version of this API carried a `<TCtx>` generic on `ToolDef`
+     * that flowed into the `context` prop. In practice it was always erased
+     * at registration, so consumers cast at the registration site and
+     * re-declared the prop shape inside the component anyway. The current
+     * shape preserves the typed-context ergonomics while removing both the
+     * useless generic and the registration-site cast.
+     */
+    component: Component<any>;
+    badge?: number | string | null;
+    /**
+     * Optional gate IDs that must all evaluate to true for the tool to be
+     * visible. Convention: `<subsystem>:<identifier>`, e.g.:
+     *
+     *   - `'permission:articles.publish'` (consumer wires a `PermissionResolver` as the `permission` evaluator)
+     *   - `'feature:video-tools'`        (consumer wires a `FeatureResolver` as the `feature` evaluator)
+     *   - `'myapp:my-custom-gate'`       (consumer wires their own evaluator)
+     *
+     * Gates are evaluated server-side via `composeDockAvailability` from
+     * `@happyvertical/smrt-svelte/workspace/server`. Each gate's prefix
+     * (text before the `:`) selects the evaluator from the caller-supplied
+     * map. The framework does NOT ship built-in evaluators — consumers
+     * register evaluators for every prefix they use. Tools with unknown
+     * prefixes throw at composition time (loud-fail beats silent-leak).
+     *
+     * Recommended prefix conventions for ecosystem cohesion (not enforced —
+     * the framework treats every prefix as caller-defined):
+     *   - `permission:` for RBAC checks (typically wraps smrt-users)
+     *   - `feature:` for feature flags (typically wraps smrt-features)
+     *   - `user-pref:` for per-user UI settings
+     *
+     * Consumers writing their own gates should pick an app-specific
+     * namespace (e.g., `myapp:`) to avoid colliding with future built-ins.
+     */
+    gates?: string[];
+}
+export interface AvailableTool {
+    id: string;
+    label?: string;
+    badge?: number | string | null;
+}
+/**
+ * Context blob the dock surfaces to tools and `fetchAvailability`. Both
+ * generics default so existing call sites keep compiling:
+ *
+ * - `TData` types the shape of `data` (route data, selection, etc.).
+ *   Defaults to `Record<string, unknown>`.
+ * - `TActions` types the shape of `actions` — the host-supplied callback
+ *   map tools may invoke to reach back into the page (`triggerSave`,
+ *   `openDialog`, etc.). Defaults to a permissive
+ *   `Record<string, (...args: any[]) => unknown>` so the untyped pattern
+ *   `dock.setContext({ actions: { triggerSave() {} } })` keeps compiling
+ *   without a generic argument.
+ *
+ * The constraint is a self-mapped
+ * `{ [K in keyof TActions]: (...args: any[]) => any }` rather than
+ * `Record<string, ...>`. This accepts interface-style action maps without
+ * an explicit string index signature — the common pattern Copilot flagged
+ * in the original PR review. A bare `Record<string, ...>` constraint
+ * rejects interfaces (which have no index signature) under strict TS,
+ * forcing consumers to use type aliases or add `[key: string]: ...`.
+ *
+ * Recommended consumer pattern: thread these generics into the tool
+ * component's own `context` prop so `context?.actions?.foo()` is fully
+ * typed without a cast.
+ *
+ * ```ts
+ * interface MyData { siteSlug: string; contentId: string }
+ * interface MyActions { triggerSave(): void; openReview(kind: string): void }
+ *
+ * // factory site:
+ * const dock = defineToolsDock<MyData, MyActions>({ ... });
+ *
+ * // tool component:
+ * let { context }: {
+ *   context: ToolsDockContext<MyData, MyActions> | null;
+ * } = $props();
+ * context?.actions?.triggerSave(); // typed
+ * ```
+ */
+export interface ToolsDockContext<TData = Record<string, unknown>, TActions extends {
+    [K in keyof TActions]: (...args: any[]) => any;
+} = Record<string, (...args: any[]) => unknown>> {
+    type: string;
+    title?: string;
+    url?: string;
+    data?: TData;
+    actions?: TActions;
+}
+/**
+ * Typed payloads for dock-owned events. Event names under the `dock:` prefix
+ * are reserved for the workspace primitives. Consumers should pick names in
+ * their own namespace (e.g. `'my-app:foo'`) and use the stringly-typed
+ * overloads of {@link ToolsDockApi.on} / {@link ToolsDockApi.emit}:
+ *
+ * ```ts
+ * dock.on<MyPayload>('my-app:selection-changed', (e) => {
+ *   // ...
+ * });
+ * dock.emit<MyPayload>('my-app:selection-changed', payload);
+ * ```
+ */
+export interface ToolsDockEvents {
+    /**
+     * Fired when `isOpen` or `activeTool` changes — i.e. `open()`, `close()`,
+     * `toggle()`, and availability-driven `activeTool` clears.
+     * Does NOT fire when only `context` changes (use `'dock:context-changed'`
+     * for that). Payload reflects post-mutation values, no-op-guarded by the
+     * same equality checks as the mutators.
+     *
+     * Useful for consumers that mirror only the open/active surface (a
+     * workbench panel, a route guard) and don't care about context refreshes.
+     */
+    'dock:state-changed': {
+        isOpen: boolean;
+        activeTool: string | null;
+    };
+    /**
+     * Fired only when `context` changes (via `setContext()` with a different
+     * reference). Does NOT fire on `open()` / `close()` / `toggle()`.
+     * No-op-guarded — same-reference `setContext` calls stay silent.
+     *
+     * Useful for consumers that mirror only the context (analytics, server
+     * sync) and don't care about open/close transitions.
+     *
+     * The payload uses the default-typed `ToolsDockContext`; the dock's
+     * event registry is shared across all `ToolsDockApi` instances and can't
+     * flow the factory's `<TData, TActions>` through to per-instance
+     * subscribers. Consumers that want typed access should either:
+     *
+     * 1. Cast at the handler site:
+     *    ```ts
+     *    dock.on('dock:context-changed', ({ context }) => {
+     *      const typed = context as ToolsDockContext<MyData, MyActions> | null;
+     *      // ... typed.data?.siteSlug
+     *    });
+     *    ```
+     * 2. Use `dock.context` inside a `$derived` — that read is typed by the
+     *    factory's `<TData, TActions>` generics on the returned instance.
+     */
+    'dock:context-changed': {
+        context: ToolsDockContext | null;
+    };
+    /**
+     * Fired by the dock after `isOpen`, `activeTool`, or `context` change —
+     * i.e. `open()`, `close()`, `toggle()`, `setContext()`, and availability
+     * changes that clear the active tool or shift visible badges. Payload
+     * reflects post-mutation values.
+     *
+     * @deprecated Prefer `'dock:state-changed'` / `'dock:context-changed'`
+     * for finer-grained subscriptions — they let consumers ignore the slice
+     * of change they don't care about. `'dock:change'` continues to fire
+     * (back-compat) and may be removed in a future major.
+     */
+    'dock:change': {
+        isOpen: boolean;
+        activeTool: string | null;
+        context: ToolsDockContext | null;
+    };
+}
+/**
+ * Public reactive API for a tools dock instance. Two generics carry through
+ * from the factory site so `dock.context` and `dock.setContext()` flow with
+ * the consumer's narrowed types:
+ *
+ * - `TData` types the shape of `context.data`. Defaults to
+ *   `Record<string, unknown>`.
+ * - `TActions` types the shape of `context.actions`. Defaults to
+ *   `Record<string, (...args: any[]) => unknown>` so the untyped pattern
+ *   `dock.setContext({ actions: { triggerSave() {} } })` keeps compiling
+ *   without a generic argument.
+ *
+ * The constraint mirrors {@link ToolsDockContext} — a self-mapped
+ * `{ [K in keyof TActions]: (...args: any[]) => any }` — so interface-style
+ * action maps satisfy the bound without requiring a string index signature.
+ *
+ * @example
+ * ```ts
+ * interface MyData { siteSlug: string }
+ * interface MyActions { triggerSave(): void }
+ *
+ * const dock = defineToolsDock<MyData, MyActions>({ tools: [...] });
+ *
+ * // typed:
+ * dock.setContext({
+ *   type: 'route',
+ *   data: { siteSlug: 'demo' },
+ *   actions: { triggerSave() {} },
+ * });
+ * const slug: string | undefined = dock.context?.data?.siteSlug;
+ * ```
+ */
+export interface ToolsDockApi<TData = Record<string, unknown>, TActions extends {
+    [K in keyof TActions]: (...args: any[]) => any;
+} = Record<string, (...args: any[]) => unknown>> {
+    readonly activeTool: string | null;
+    readonly isOpen: boolean;
+    readonly availableTools: ReadonlyArray<AvailableTool>;
+    /**
+     * The current dock context (route data, selection, etc.) as supplied via
+     * `setContext()`. Typed against the factory's `<TData, TActions>` generics —
+     * narrow them at the `defineToolsDock<TData, TActions>(...)` call site for
+     * typed access without a cast.
+     */
+    readonly context: ToolsDockContext<TData, TActions> | null;
+    open(id?: string): void;
+    close(): void;
+    toggle(id?: string): void;
+    setContext(ctx: ToolsDockContext<TData, TActions> | null): void;
+    /**
+     * Force a re-run of the `fetchAvailability` callback with the current
+     * context. Useful when a side-channel event signals that availability or
+     * badges changed without the dock context itself changing (e.g. a job
+     * completes, a content row's status flips, a websocket "updated" event
+     * arrives). `setContext()` short-circuits on strict-equal references so
+     * the only way to refetch with the same context is to call this method.
+     *
+     * If no `fetchAvailability` is configured, this resets `availableTools`
+     * to the full registered set (same behavior as the implicit initial
+     * snapshot). Concurrent / overlapping calls are token-gated — stale
+     * results are dropped, only the latest fetch applies.
+     */
+    refreshAvailability(): void;
+    /**
+     * Emit an event to all subscribers. The typed overload covers built-in
+     * `'dock:*'` events (see {@link ToolsDockEvents}); the stringly-typed
+     * overload covers any consumer-defined event name. Consumers should pick
+     * names in their own namespace (e.g. `'my-app:foo'`) — `'dock:*'` is
+     * reserved for the workspace primitives.
+     */
+    emit<K extends keyof ToolsDockEvents>(event: K, payload: ToolsDockEvents[K]): void;
+    emit<TPayload>(event: string, payload: TPayload): void;
+    /**
+     * Subscribe to a dock event. Returns an unsubscribe function. When the
+     * event name is a key of {@link ToolsDockEvents} (i.e. `'dock:*'`), the
+     * payload type is inferred automatically; otherwise an explicit
+     * `TPayload` may be supplied via the stringly-typed overload.
+     *
+     * @example
+     * ```ts
+     * const off = dock.on('dock:change', ({ isOpen, activeTool, context }) => {
+     *   // mirror to another store
+     * });
+     * // ...later
+     * off();
+     * ```
+     */
+    on<K extends keyof ToolsDockEvents>(event: K, handler: (payload: ToolsDockEvents[K]) => void): () => void;
+    on<TPayload>(event: string, handler: (payload: TPayload) => void): () => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/components/workspace/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/workspace/types.ts"],"names":[],"mappings":"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"}

package/dist/components/workspace/types.js

@@ -0,0 +1,6 @@
+/**
+ * Shared types for the workspace shell primitives.
+ *
+ * See @happyvertical/smrt#1226 (epic) and #1227 / #1228 / #1229 (implementers).
+ */
+export {};

package/dist/hooks/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Svelte hooks for app state, AI, auth, socket, and theme functionality
+ */
+export * from './useAppState.svelte.js';
+export * from './useAuth.svelte.js';
+export * from './useLLM.svelte.js';
+export * from './useSocket.svelte.js';
+export * from './useSTT.svelte.js';
+export * from './useTheme.js';
+export * from './useTTS.svelte.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC"}

package/dist/hooks/index.js

@@ -0,0 +1,10 @@
+/**
+ * Svelte hooks for app state, AI, auth, socket, and theme functionality
+ */
+export * from './useAppState.svelte.js';
+export * from './useAuth.svelte.js';
+export * from './useLLM.svelte.js';
+export * from './useSocket.svelte.js';
+export * from './useSTT.svelte.js';
+export * from './useTheme.js';
+export * from './useTTS.svelte.js';

package/dist/hooks/useAppState.svelte.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Hook to access app state from context
+ */
+import type { AppMode } from '../state/app-state.js';
+import type { SmrtAppStateManager } from '../state/app-state.svelte.js';
+/**
+ * Get the app state manager from context
+ *
+ * @throws If called outside of SmrtProvider
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useAppState } from '@happyvertical/smrt-svelte';
+ *
+ *   const app = useAppState();
+ *
+ *   // Access reactive state
+ *   $: mode = app.state.mode;
+ *   $: isSmrt = mode === 'smrt';
+ * </script>
+ * ```
+ */
+export declare function useAppState(): SmrtAppStateManager;
+/**
+ * Try to get app state, returns null if not in context
+ */
+export declare function tryUseAppState(): SmrtAppStateManager | null;
+/**
+ * Helper to check if smrt mode is enabled
+ */
+export declare function useIsSmrt(): boolean;
+/**
+ * Helper to get current mode
+ */
+export declare function useMode(): AppMode;
+/**
+ * Helper to check permissions
+ */
+export declare function usePermissions(): {
+    has: (permission: string) => boolean;
+    hasAll: (permissions: string[]) => boolean;
+    hasAny: (permissions: string[]) => boolean;
+    list: string[];
+};
+//# sourceMappingURL=useAppState.svelte.d.ts.map

package/dist/hooks/useAppState.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAppState.svelte.d.ts","sourceRoot":"","sources":["../../src/hooks/useAppState.svelte.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAGxE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,IAAI,mBAAmB,CAEjD;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,mBAAmB,GAAG,IAAI,CAE3D;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,OAAO,CAGnC;AAED;;GAEG;AACH,wBAAgB,OAAO,IAAI,OAAO,CAGjC;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI;IAChC,GAAG,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IACrC,MAAM,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC;IAC3C,MAAM,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC;IAC3C,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAWA"}

package/dist/hooks/useAppState.svelte.js

@@ -0,0 +1,59 @@
+/**
+ * Hook to access app state from context
+ */
+import { getAppStateContext, tryGetAppStateContext } from '../state/context.js';
+/**
+ * Get the app state manager from context
+ *
+ * @throws If called outside of SmrtProvider
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useAppState } from '@happyvertical/smrt-svelte';
+ *
+ *   const app = useAppState();
+ *
+ *   // Access reactive state
+ *   $: mode = app.state.mode;
+ *   $: isSmrt = mode === 'smrt';
+ * </script>
+ * ```
+ */
+export function useAppState() {
+    return getAppStateContext();
+}
+/**
+ * Try to get app state, returns null if not in context
+ */
+export function tryUseAppState() {
+    return tryGetAppStateContext();
+}
+/**
+ * Helper to check if smrt mode is enabled
+ */
+export function useIsSmrt() {
+    const app = getAppStateContext();
+    return app.state.mode === 'smrt';
+}
+/**
+ * Helper to get current mode
+ */
+export function useMode() {
+    const app = getAppStateContext();
+    return app.state.mode;
+}
+/**
+ * Helper to check permissions
+ */
+export function usePermissions() {
+    const app = getAppStateContext();
+    return {
+        has: (permission) => app.hasPermission(permission),
+        hasAll: (permissions) => app.hasAllPermissions(permissions),
+        hasAny: (permissions) => app.hasAnyPermission(permissions),
+        get list() {
+            return app.state.session.permissions;
+        },
+    };
+}

package/dist/hooks/useAuth.svelte.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Hook to access authentication state
+ */
+import type { User } from '../state/app-state.js';
+/**
+ * Access authentication state and permission checking
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useAuth } from '@happyvertical/smrt-svelte';
+ *
+ *   const auth = useAuth();
+ * </script>
+ *
+ * {#if auth.isAuthenticated}
+ *   <p>Welcome, {auth.user?.email}</p>
+ *
+ *   {#if auth.hasPermission('articles.create')}
+ *     <button>Create Article</button>
+ *   {/if}
+ * {:else}
+ *   <a href="/login">Sign In</a>
+ * {/if}
+ * ```
+ */
+export declare function useAuth(): {
+    /** The authenticated user (null if not authenticated) */
+    readonly user: User | null;
+    /** Whether a user is authenticated */
+    readonly isAuthenticated: boolean;
+    /** List of user's permissions */
+    readonly permissions: readonly string[];
+    /** Check if user has a specific permission */
+    hasPermission: (permission: string) => boolean;
+    /** Check if user has all of the specified permissions */
+    hasAllPermissions: (permissions: string[]) => boolean;
+    /** Check if user has any of the specified permissions */
+    hasAnyPermission: (permissions: string[]) => boolean;
+};
+//# sourceMappingURL=useAuth.svelte.d.ts.map

package/dist/hooks/useAuth.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuth.svelte.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.svelte.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAGlD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,OAAO,IAAI;IACzB,yDAAyD;IACzD,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAC3B,sCAAsC;IACtC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,iCAAiC;IACjC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,8CAA8C;IAC9C,aAAa,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IAC/C,yDAAyD;IACzD,iBAAiB,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC;IACtD,yDAAyD;IACzD,gBAAgB,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC;CACtD,CAmBA"}

package/dist/hooks/useAuth.svelte.js

@@ -0,0 +1,43 @@
+/**
+ * Hook to access authentication state
+ */
+import { getAppStateContext } from '../state/context.js';
+/**
+ * Access authentication state and permission checking
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { useAuth } from '@happyvertical/smrt-svelte';
+ *
+ *   const auth = useAuth();
+ * </script>
+ *
+ * {#if auth.isAuthenticated}
+ *   <p>Welcome, {auth.user?.email}</p>
+ *
+ *   {#if auth.hasPermission('articles.create')}
+ *     <button>Create Article</button>
+ *   {/if}
+ * {:else}
+ *   <a href="/login">Sign In</a>
+ * {/if}
+ * ```
+ */
+export function useAuth() {
+    const app = getAppStateContext();
+    return {
+        get user() {
+            return app.state.session.user;
+        },
+        get isAuthenticated() {
+            return app.state.session.isAuthenticated;
+        },
+        get permissions() {
+            return app.state.session.permissions;
+        },
+        hasPermission: (permission) => app.hasPermission(permission),
+        hasAllPermissions: (permissions) => app.hasAllPermissions(permissions),
+        hasAnyPermission: (permissions) => app.hasAnyPermission(permissions),
+    };
+}