najm-kit 2.9.0 → 2.11.0

package/dist/{formFill-BcH-m9Kf.d.ts → NNotFoundState-D1CLLLxc.d.ts}

@@ -1,6 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
+import React__default, { ReactNode } from 'react';
 import { ZodTypeAny, TypeOf } from 'zod';
+import { LucideIcon } from 'lucide-react';
 
 interface NBrandingValue {
     /** Used as the logo's `alt` when the logo does not set one. */
@@ -94,4 +95,85 @@ type FormDevTools<T extends ZodTypeAny = ZodTypeAny> = boolean | FormDevToolsCon
 /** Build form-shaped test values from a Zod object schema. */
 declare function buildFormFill<TSchema extends ZodTypeAny>(schema: TSchema, overrides?: FormFillOverrides): Partial<TypeOf<TSchema>>;
 
-export { type FormDevToolsOptions as F, type NBrandingInput as N, type FormDevTools as a, type FormDevToolsConfig as b, type FormFillOverride as c, type FormFillOverrides as d, type NBrandingEditorValue as e, type NBrandingPayload as f, NBrandingProvider as g, NBrandingStateProvider as h, type NBrandingStateProviderProps as i, type NBrandingValue as j, buildFormFill as k, useNBrandingEditor as l, normalizeBranding as n, useNBranding as u };
+/**
+ * Shared surface a feedback state renders into.
+ *
+ * - `inline` (default) keeps each component's existing padding and sizing. No
+ *   landmark, no page gutter.
+ * - `panel` is for table bodies, card bodies, dialogs, sheets, and nested
+ *   surfaces. Centered with a minimum height, no landmark, no page gutter.
+ * - `page` is for actual route-level states. Uses page spacing from the design
+ *   config, but renders through `NPageLayout as="div"` so it never introduces
+ *   another `<main>` inside an already-paged shell.
+ */
+type NFeedbackSurface = "inline" | "panel" | "page";
+
+interface NLoadingStateProps {
+    label?: string;
+    className?: string;
+    fullScreen?: boolean;
+    spinnerVariant?: "default" | "circle" | "pinwheel" | "circle-filled" | "ellipsis" | "ring" | "bars";
+    spinnerSize?: number;
+    /**
+     * Layout surface. `inline` is the default and preserves the legacy look;
+     * `panel` is for table/dialog/sheet bodies; `page` uses page spacing
+     * without introducing a `<main>`. `fullScreen` takes precedence and renders
+     * the fixed viewport overlay regardless of surface.
+     */
+    surface?: NFeedbackSurface;
+}
+declare function NLoadingState({ label, className, fullScreen, spinnerVariant, spinnerSize, surface, }: NLoadingStateProps): react_jsx_runtime.JSX.Element;
+
+interface NErrorStateProps {
+    title?: string;
+    message?: string;
+    onRetry?: () => void;
+    retryLabel?: string;
+    className?: string;
+    icon?: React__default.ReactNode;
+    /** Layout surface. See `NLoadingStateProps.surface`. */
+    surface?: NFeedbackSurface;
+}
+declare function NErrorState({ title, message, onRetry, retryLabel, className, icon, surface, }: NErrorStateProps): react_jsx_runtime.JSX.Element;
+
+interface NEmptyStateProps {
+    title?: string;
+    description?: string;
+    icon?: React__default.ReactNode | LucideIcon;
+    action?: React__default.ReactNode;
+    className?: string;
+    /** Layout surface. See `NLoadingStateProps.surface`. */
+    surface?: NFeedbackSurface;
+}
+declare function NEmptyState({ title, description, icon, action, className, surface, }: NEmptyStateProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * First-class "access denied" state.
+ *
+ * Thin preset over `NEmptyState`. Defaults to the page surface and a token-
+ * backed `ShieldOff` icon, with title and description resolved from the
+ * provider's forbidden defaults. None of the routing, authorization,
+ * metadata, or framework-link behavior lives here — that is the
+ * application's responsibility.
+ */
+interface NForbiddenStateProps extends NEmptyStateProps {
+    title?: string;
+    description?: string;
+}
+declare function NForbiddenState(props: NForbiddenStateProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * First-class "page not found" state.
+ *
+ * Thin preset over `NEmptyState`. Defaults to the page surface and a `Compass`
+ * icon, with title and description resolved from the provider's not-found
+ * defaults. None of the route-target, metadata, redirect, or framework-link
+ * behavior lives here.
+ */
+interface NNotFoundStateProps extends NEmptyStateProps {
+    title?: string;
+    description?: string;
+}
+declare function NNotFoundState(props: NNotFoundStateProps): react_jsx_runtime.JSX.Element;
+
+export { type FormDevToolsOptions as F, type NBrandingInput as N, NEmptyState as a, type NEmptyStateProps as b, NErrorState as c, type NErrorStateProps as d, type NFeedbackSurface as e, NForbiddenState as f, type NForbiddenStateProps as g, NLoadingState as h, type NLoadingStateProps as i, NNotFoundState as j, type NNotFoundStateProps as k, type FormDevTools as l, type FormDevToolsConfig as m, type FormFillOverride as n, type FormFillOverrides as o, type NBrandingEditorValue as p, type NBrandingPayload as q, NBrandingProvider as r, NBrandingStateProvider as s, type NBrandingStateProviderProps as t, type NBrandingValue as u, buildFormFill as v, normalizeBranding as w, useNBranding as x, useNBrandingEditor as y };

package/dist/NajmUIProvider-cNCb8Tpn.d.ts

@@ -0,0 +1,327 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import React__default from 'react';
+import { e as NajmMode, a as NajmDesignConfig } from './design-types-Rkpt8Pg1.js';
+import { b as NTablePaginationLabels, N as NajmTranslate } from './paginationLabels-dZLSNxfo.js';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+
+/**
+ * Defaults every `NTable` beneath the provider inherits.
+ *
+ * Localized copy is the motivating case: an application with more than a couple
+ * of tables should not repeat the same label bundle at every render site, and
+ * an application with more than one locale should not have to remember to.
+ */
+interface NTableDefaults {
+    paginationLabels?: NTablePaginationLabels;
+}
+/**
+ * Supply table defaults to everything below.
+ *
+ * `value` is passed straight through, so memoize it in the caller — an inline
+ * object literal rebuilds on every render of the shell and re-renders every
+ * table beneath it. Most label fields are functions, so `useMemo` on the
+ * translator is usually the whole job.
+ */
+declare function NTableDefaultsProvider({ children, value, }: {
+    children: React__default.ReactNode;
+    value: NTableDefaults;
+}): react_jsx_runtime.JSX.Element;
+declare function useNTableDefaults(): NTableDefaults;
+
+type NIconSource = React__default.ReactElement | React__default.ComponentType<any> | React__default.ExoticComponent<any> | string | {
+    src: string;
+    alt?: string;
+};
+type NIconProps = Omit<React__default.HTMLAttributes<HTMLElement>, "children"> & {
+    size?: string | number;
+    icon: NIconSource;
+    alt?: string;
+    color?: string;
+    className?: string;
+    strokeWidth?: number;
+    stroke?: string;
+    fill?: string;
+    onClick?: React__default.MouseEventHandler<HTMLElement>;
+    style?: React__default.CSSProperties;
+};
+declare const NIcon: React__default.FC<NIconProps>;
+
+declare const badgeVariants: (props?: {
+    variant?: "secondary" | "destructive" | "default" | "outline" | "success" | "warning";
+} & class_variance_authority_types.ClassProp) => string;
+declare const badgeColorVariants: (props?: {
+    color?: "neutral" | "primary" | "accent" | "secondary" | "destructive" | "success" | "warning" | "info";
+    look?: "solid" | "outline" | "soft" | "dash";
+    size?: "sm" | "md" | "lg";
+    shape?: "default" | "square" | "pill";
+} & class_variance_authority_types.ClassProp) => string;
+type BadgeVariantProps = VariantProps<typeof badgeVariants>;
+type BadgeColorVariantProps = VariantProps<typeof badgeColorVariants>;
+type BadgeColor = NonNullable<BadgeColorVariantProps["color"]>;
+type BadgeLook = NonNullable<BadgeColorVariantProps["look"]>;
+type BadgeDisplayLook = BadgeLook | "minimal" | "text";
+type BadgeSize = NonNullable<BadgeColorVariantProps["size"]>;
+type BadgeShape = NonNullable<BadgeColorVariantProps["shape"]>;
+type BadgeVariant = NonNullable<BadgeVariantProps["variant"]>;
+type BadgeIcon = NIconSource;
+type BadgeProps = React.ComponentProps<"span"> & {
+    asChild?: boolean;
+    variant?: BadgeVariantProps["variant"];
+    status?: string;
+    statusMap?: Record<string, BadgeColor>;
+    label?: string;
+    showIcon?: boolean;
+    color?: BadgeColor;
+    look?: BadgeDisplayLook;
+    size?: BadgeSize;
+    shape?: BadgeShape;
+    icon?: BadgeIcon;
+    iconMap?: Record<string, BadgeIcon>;
+    iconPosition?: "left" | "right";
+};
+declare function Badge({ className, variant, status, statusMap, label, showIcon, color, look, size, shape, icon, iconMap, iconPosition, asChild, children, style, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+declare const NBadge: typeof Badge;
+type NBadgeLook = BadgeDisplayLook;
+type NBadgeProps = BadgeProps;
+
+/**
+ * Application-wide presentation policy for `<NBadge status="…" />`.
+ *
+ * This is the whole reason a project ends up with a `StatusBadge` wrapper: the
+ * badge itself is already correct, but every call site has to repeat the same
+ * look, the same shape, and the same translation lookup. Declared once on the
+ * provider, none of that reaches a call site.
+ *
+ * What stays in the application: the vocabulary and the catalog. `statusMap`
+ * and `statusLabelKeys` take *its* status tokens and *its* catalog keys — this
+ * package ships neither.
+ */
+interface NBadgeDefaults {
+    look?: NBadgeLook;
+    shape?: BadgeShape;
+    size?: BadgeSize;
+    showIcon?: boolean;
+    /** Status token to badge color. Merged over the packaged vocabulary. */
+    statusMap?: Record<string, BadgeColor>;
+    /** Badge color to icon, used when `showIcon` is on. */
+    iconMap?: Record<string, BadgeIcon>;
+    /** Status token to finished label text. Wins over `statusLabelKeys`. */
+    statusLabels?: Record<string, string>;
+    /** Status token to catalog key, resolved through the provider's `t`. */
+    statusLabelKeys?: Record<string, string>;
+}
+
+/**
+ * Optional literal labels, supplied as `feedbackDefaults.labels`. Each field
+ * is independent: an application can localize one feedback label without
+ * touching the others.
+ *
+ * `errorMessage` is the only key without a packaged fallback. A consumer that
+ * supplies one opts a generic error state into rendering a body; absent that
+ * opt-in, the no-provider behavior is unchanged.
+ */
+interface NFeedbackLabels {
+    loadingLabel?: string;
+    emptyTitle?: string;
+    errorTitle?: string;
+    errorMessage?: string;
+    retryLabel?: string;
+    forbiddenTitle?: string;
+    forbiddenDescription?: string;
+    notFoundTitle?: string;
+    notFoundDescription?: string;
+}
+/**
+ * Map from a feedback field to a translation catalog key. Resolved through the
+ * provider's structural `t`. Optional per-field; a missing key falls through
+ * to the literal default, then to packaged English.
+ */
+interface NFeedbackLabelKeys {
+    loadingLabel?: string;
+    emptyTitle?: string;
+    errorTitle?: string;
+    errorMessage?: string;
+    retryLabel?: string;
+    forbiddenTitle?: string;
+    forbiddenDescription?: string;
+    notFoundTitle?: string;
+    notFoundDescription?: string;
+}
+/**
+ * Provider-level defaults for the shared feedback components.
+ *
+ * Threaded through `NajmUIProvider.feedbackDefaults` and inherited by the
+ * `next` and `app` adapters. No second adapter prop or translation source:
+ * the same structural `t` every table and badge reads is what these labels
+ * route through.
+ */
+interface NFeedbackDefaults {
+    /**
+     * Literal overrides. A field that is `undefined` here still resolves through
+     * `labelKeys` and the packaged English fallback.
+     */
+    labels?: NFeedbackLabels;
+    /**
+     * Catalog keys resolved through the provider's `t`. Memoize the object: a
+     * fresh identity on every render rebuilds the label bundle and re-renders
+     * every feedback state beneath the provider.
+     */
+    labelKeys?: NFeedbackLabelKeys;
+    /**
+     * Catalog prefix for translated keys. Keys are read as `<prefix>.<field>`.
+     * Defaults to `"common.feedback"`.
+     */
+    prefix?: string;
+}
+
+/**
+ * Theme and time zone, the two preferences that outlive a render.
+ *
+ * Both are *uncontrolled*: the `initial*` props seed state the provider owns
+ * from then on, and later changes to those props are ignored. That is the
+ * shape the server hand-off wants — the page is rendered once against a cookie,
+ * and every change after that originates here.
+ *
+ * Persistence is not this provider's business. It applies the change to the
+ * document, then hands the new value to a callback the application supplies.
+ * See `NajmNextUIProvider` in `najm-kit/next` for the cookie-endpoint wiring.
+ */
+interface NajmPreferencesContextValue {
+    theme: NajmMode;
+    setTheme: (theme: NajmMode) => Promise<void>;
+    timeZone: string;
+    setTimeZone: (timeZone: string) => Promise<void>;
+}
+declare const DEFAULT_TIME_ZONE = "UTC";
+interface NajmPreferencesProviderProps {
+    children: React.ReactNode;
+    /** Seeds theme state; ignored after mount. Defaults to `"light"`. */
+    initialTheme?: NajmMode;
+    /** Seeds time zone state; ignored after mount. Defaults to `"UTC"`. */
+    initialTimeZone?: string;
+    /** Persist the new theme. Rejections propagate to the `setTheme` caller. */
+    onThemeChange?: (theme: NajmMode) => void | Promise<void>;
+    /** Persist the new time zone. Rejections propagate to `setTimeZone`. */
+    onTimeZoneChange?: (timeZone: string) => void | Promise<void>;
+    /**
+     * Sanitize a time zone before it is stored.
+     *
+     * Defaults to an IANA check that falls back to `DEFAULT_TIME_ZONE`, which is
+     * what every application wanted from the callback it used to have to supply.
+     * Pass one to narrow further — a fixed set backing a picker, say.
+     */
+    normalizeTimeZone?: (value: string) => string;
+}
+/**
+ * Standalone preferences, without the design and table layers.
+ *
+ * `NajmUIProvider` renders this internally, so most applications never name it.
+ * It is exported for the case where something *above* the design layer needs to
+ * read the theme — a runtime theme editor, typically, which owns the design
+ * config and therefore has to sit above the provider consuming it. Hoisting
+ * preferences out is then a reorder rather than a fork.
+ */
+declare function NajmPreferencesProvider({ children, initialTheme, initialTimeZone, onThemeChange, onTimeZoneChange, normalizeTimeZone, }: NajmPreferencesProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Returns the context when one is mounted, or `null`.
+ *
+ * `NajmUIProvider` uses this to defer to an outer `NajmPreferencesProvider`
+ * instead of shadowing it, so nesting the two is well-defined rather than
+ * quietly producing two disagreeing themes.
+ */
+declare function useNajmPreferencesContext(): NajmPreferencesContextValue | null;
+/** The live theme and a setter that persists through `onThemeChange`. */
+declare function useNajmTheme(): Pick<NajmPreferencesContextValue, "theme" | "setTheme">;
+/** The live time zone and a setter that persists through `onTimeZoneChange`. */
+declare function useNajmTimeZone(): Pick<NajmPreferencesContextValue, "timeZone" | "setTimeZone">;
+
+interface NajmUIProviderProps extends Omit<NajmPreferencesProviderProps, "children"> {
+    children: React.ReactNode;
+    /**
+     * The design config handed to `NajmDesignProvider`, owned by the application.
+     *
+     * Optional, and deliberately so: an application with no runtime theme editor
+     * has nothing to put here, and requiring it was the only reason such an
+     * application still had to author a provider file just to hold a constant.
+     *
+     * Prefer `initialDesign` for a theme editor. Passing `design` means the
+     * application holds the draft state itself, which is the file this provider
+     * exists to delete.
+     */
+    design?: NajmDesignConfig;
+    /**
+     * Seeds design state this provider owns from then on; ignored after mount.
+     * A theme editor drives it through `useNajmDesignEditor`.
+     */
+    initialDesign?: NajmDesignConfig;
+    /**
+     * Forwarded to `NajmDesignProvider`, merged over a `min-h-full` default.
+     *
+     * The default is not decoration. `NajmThemeProvider` renders a real `div`
+     * between the document body and the application, and a block box of
+     * automatic height severs any `h-full` chain below it — every application
+     * mounting this at the root was passing the same class back to repair that.
+     * It is inert where it is not needed: a percentage `min-height` against an
+     * auto-height parent imposes no constraint.
+     *
+     * Merged with `cn`, so a conflicting utility here still wins.
+     */
+    className?: string;
+    /**
+     * Translator for the pagination labels. Omit it and the packaged English
+     * applies — the provider is still worth mounting for design and preferences.
+     *
+     * Memoize it. The labels are rebuilt whenever its identity changes, and
+     * rebuilding them re-renders every table beneath.
+     */
+    t?: NajmTranslate;
+    /** Catalog prefix for the labels. Defaults to `"common.pagination"`. */
+    paginationKeyPrefix?: string;
+    /**
+     * Per-key overrides layered over the translated labels. Memoize it, for the
+     * same reason as `t`.
+     */
+    tableDefaults?: NTableDefaults;
+    /**
+     * Presentation policy for `<NBadge status="…" />`: the look, the shape, and
+     * the map from the application's status tokens to its catalog keys.
+     *
+     * This is the prop that deletes a project's `StatusBadge` wrapper. Memoize it
+     * for the same reason as `t`.
+     */
+    badgeDefaults?: NBadgeDefaults;
+    /**
+     * Defaults for the shared feedback state components — loading, empty, error,
+     * forbidden, and not-found. Each label resolves through the provider's `t`
+     * the same way pagination and badge labels do, so the same translator
+     * reaches every state without a second bridge.
+     *
+     * Memoize the object: a fresh identity rebuilds the resolved bundle and
+     * re-renders every feedback state beneath.
+     */
+    feedbackDefaults?: NFeedbackDefaults;
+}
+/**
+ * The one provider a Najm application mounts for UI concerns.
+ *
+ * Composes three things that otherwise get copied between projects: theme and
+ * time zone state with async persistence, a `NajmDesignProvider` fed the live
+ * theme, and `NTable` pagination labels derived from the application's
+ * translator.
+ *
+ * What it deliberately does not own: auth, react-query, and the translation
+ * catalog. Those stay in the application — folding them in would make a UI
+ * package depend on `najm-auth` and `@tanstack/react-query` and turn it into a
+ * framework. Persistence is injected as callbacks so this entry imports
+ * nothing from `next`; see `NajmNextUIProvider` in `najm-kit/next`.
+ *
+ * Rendering this under an existing `NajmPreferencesProvider` is supported: the
+ * outer one wins and the preference props here are ignored. That is what lets
+ * an application with a runtime theme editor hoist preferences above its
+ * design context without forking this component.
+ */
+declare function NajmUIProvider({ children, design, initialDesign, className, t, paginationKeyPrefix, tableDefaults, badgeDefaults, feedbackDefaults, initialTheme, initialTimeZone, onThemeChange, onTimeZoneChange, normalizeTimeZone, }: NajmUIProviderProps): react_jsx_runtime.JSX.Element;
+
+export { useNajmPreferencesContext as A, type BadgeColor as B, useNajmTheme as C, DEFAULT_TIME_ZONE as D, useNajmTimeZone as E, type NFeedbackDefaults as N, type NFeedbackLabelKeys as a, type NFeedbackLabels as b, type NajmUIProviderProps as c, type NIconSource as d, type BadgeShape as e, Badge as f, type BadgeIcon as g, type BadgeLook as h, type BadgeProps as i, type BadgeSize as j, type BadgeVariant as k, NBadge as l, type NBadgeDefaults as m, type NBadgeLook as n, type NBadgeProps as o, NIcon as p, type NIconProps as q, type NTableDefaults as r, NTableDefaultsProvider as s, type NajmPreferencesContextValue as t, NajmPreferencesProvider as u, type NajmPreferencesProviderProps as v, NajmUIProvider as w, badgeColorVariants as x, badgeVariants as y, useNTableDefaults as z };

package/dist/adapters/app.d.ts

@@ -1,12 +1,17 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Translations } from 'najm-i18n';
-import { F as FormDevToolsOptions, N as NBrandingInput } from '../formFill-BcH-m9Kf.js';
+import { F as FormDevToolsOptions, N as NBrandingInput } from '../NNotFoundState-D1CLLLxc.js';
+export { a as NEmptyState, b as NEmptyStateProps, c as NErrorState, d as NErrorStateProps, e as NFeedbackSurface, f as NForbiddenState, g as NForbiddenStateProps, h as NLoadingState, i as NLoadingStateProps, j as NNotFoundState, k as NNotFoundStateProps } from '../NNotFoundState-D1CLLLxc.js';
 import { NajmNextUIProviderProps } from './next.js';
+export { N as NFeedbackDefaults, a as NFeedbackLabelKeys, b as NFeedbackLabels } from '../NajmUIProvider-cNCb8Tpn.js';
 import 'react';
 import 'zod';
-import '../NajmUIProvider-CI_73GEp.js';
+import 'lucide-react';
+import 'next/image';
 import '../design-types-Rkpt8Pg1.js';
 import '../paginationLabels-dZLSNxfo.js';
+import 'class-variance-authority/types';
+import 'class-variance-authority';
 
 /** Branding shown by the kit's chrome. Purely presentational values. */
 interface NajmAppBranding {

package/dist/adapters/app.mjs

@@ -1,9 +1,12 @@
 'use client';
-import { FormDevToolsProvider, NBrandingStateProvider, NajmFormatProvider } from '../chunk-GHMR45H3.mjs';
-import { NajmNextUIProvider } from '../chunk-IRFFSAO2.mjs';
-import '../chunk-USZUOJMK.mjs';
+import { FormDevToolsProvider, NBrandingStateProvider, NajmFormatProvider } from '../chunk-2GFWF46W.mjs';
+export { NEmptyState, NErrorState, NForbiddenState, NLoadingState, NNotFoundState } from '../chunk-2GFWF46W.mjs';
+import { NajmNextUIProvider } from '../chunk-CE7MVEJ2.mjs';
+import '../chunk-EEBLEDNI.mjs';
+import '../chunk-XZL32HFR.mjs';
 import '../chunk-KVZACF4G.mjs';
 import '../chunk-JABLSOQN.mjs';
+import '../chunk-TFHWLE7N.mjs';
 import * as React from 'react';
 import { I18nProvider, useTranslation } from 'najm-i18n/react';
 import { jsx } from 'react/jsx-runtime';

package/dist/adapters/next.d.ts

@@ -1,8 +1,11 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React__default from 'react';
-import { N as NajmUIProviderProps } from '../NajmUIProvider-CI_73GEp.js';
+import { ImageProps } from 'next/image';
+import { c as NajmUIProviderProps } from '../NajmUIProvider-cNCb8Tpn.js';
 import '../design-types-Rkpt8Pg1.js';
 import '../paginationLabels-dZLSNxfo.js';
+import 'class-variance-authority/types';
+import 'class-variance-authority';
 
 interface NextLinkAdapterProps extends Record<string, any> {
     href: string;
@@ -20,6 +23,28 @@ declare function useNextNavigationAdapter(): {
     push: (path: string) => void;
     replace: (path: string) => void;
 };
+interface NNextImageProps extends Omit<ImageProps, 'src' | 'onError'> {
+    src: string;
+    /** Swapped in once `src` fails to load. Tried exactly once. */
+    fallbackSrc?: string;
+    onError?: ImageProps['onError'];
+}
+/**
+ * `next/image` with the fallback behavior of `NImage`, for applications that
+ * want the optimizer, the layout reservation, and `fill`/`sizes`.
+ *
+ * Lives only in `najm-kit/next`. The root entry must stay installable without
+ * Next, which is why this cannot be a prop on `NImage`.
+ *
+ * It classifies nothing. An application that serves an asset from a route the
+ * browser must reach directly — an authenticated one, say — passes
+ * `unoptimized` at the call site, because whether a route is protected is the
+ * application's fact and not something a URL shape can be read for. Note also
+ * what `unoptimized` is not: it changes delivery mechanics only. Session
+ * validation, permissions, and what bytes come back remain entirely the
+ * backend's.
+ */
+declare function NNextImage({ src, fallbackSrc, loading, priority, onError, ...props }: NNextImageProps): react_jsx_runtime.JSX.Element;
 /** Where `NajmNextUIProvider` POSTs each preference. */
 interface NajmNextUIEndpoints {
     /** Defaults to `/api/ui-theme`. Receives `{ theme }`. */
@@ -50,4 +75,4 @@ interface NajmNextUIProviderProps extends Omit<NajmUIProviderProps, 'onThemeChan
  */
 declare function NajmNextUIProvider({ endpoints, refreshOnChange, ...props }: NajmNextUIProviderProps): react_jsx_runtime.JSX.Element;
 
-export { type NajmNextUIEndpoints, NajmNextUIProvider, type NajmNextUIProviderProps, NextLinkAdapter, type NextLinkAdapterProps, useNextNavigationAdapter };
+export { NNextImage, type NNextImageProps, type NajmNextUIEndpoints, NajmNextUIProvider, type NajmNextUIProviderProps, NextLinkAdapter, type NextLinkAdapterProps, useNextNavigationAdapter };

package/dist/adapters/next.mjs

@@ -1,3 +1,3 @@
-export { NajmNextUIProvider, NextLinkAdapter, useNextNavigationAdapter } from '../chunk-IRFFSAO2.mjs';
-import '../chunk-USZUOJMK.mjs';
+export { NNextImage, NajmNextUIProvider, NextLinkAdapter, useNextNavigationAdapter } from '../chunk-CE7MVEJ2.mjs';
+import '../chunk-EEBLEDNI.mjs';
 import '../chunk-KVZACF4G.mjs';