@plitzi/sdk-shared 0.38.5 → 0.38.7

package/dist/style/styleStates.d.ts

@@ -7,15 +7,22 @@
  * `focus-visible` is the focus ring a keyboard user needs and a mouse user does not; `focus-within` dresses a
  * container while anything inside it has focus — a field wrapper around its input.
  *
- * `current` is the link to the page being shown — the navigation item of where the visitor is. The link says so itself
- * (`aria-current="page"`, what a screen reader announces too), so a header written once in a layout marks the right item
- * on every page, which a class chosen per page could not.
+ * `current` is the chosen one of a set: the link to the page being shown (`aria-current`), the option pressed in a group
+ * of toggles (`aria-pressed`), the selected tab (`aria-selected`). The element says so itself — what a screen reader
+ * announces too — so a header written once in a layout marks the right item on every page, and a theme switch its
+ * chosen scheme, which a class chosen per page could not.
+ *
+ * `expanded` is the control that opens a panel while the panel is open — a dropdown's trigger, an accordion's header, a
+ * menu button (`aria-expanded`). The control says so itself, as the chosen one of a set does.
  *
  * `hidden` is not a pseudo-class: it is how an element looks while its `visible` says no — where it goes as it hides,
  * and where it comes from as it shows. With a transition on the class (`display` among what it transitions, and
  * `transition-behavior: allow-discrete`), a panel fades or slides in and out instead of blinking.
+ *
+ * `first`, `last`, `odd` and `even` are where the element sits among its siblings — the row of a list that has no
+ * divider above it, the alternate rows of a table. They count every sibling, as `:nth-child` does.
  */
-export declare const STYLE_STATES: readonly ["hover", "focus", "focus-visible", "focus-within", "active", "disabled", "checked", "visited", "current", "hidden"];
+export declare const STYLE_STATES: readonly ["hover", "focus", "focus-visible", "focus-within", "active", "disabled", "checked", "visited", "current", "expanded", "hidden", "first", "last", "odd", "even"];
 /** What the SDK puts on an element whose `visible` says no: `display: none`, and what the `hidden` state selects. */
 export declare const HIDDEN_CLASS = "plitzi-component--hidden";
 export declare const STYLE_STATE_LABELS: Record<(typeof STYLE_STATES)[number], string>;
@@ -25,11 +32,20 @@ export declare const isKnownState: (state: string) => state is (typeof STYLE_STA
  * A state outside the list keeps its place after the known ones.
  */
 export declare const inCascadeOrder: <T>(states: Record<string, T>) => [string, T][];
-/** What a link to the page being shown carries, and what the `current` state selects. */
-export declare const CURRENT_PAGE_SELECTOR = "[aria-current=\"page\"]";
 /**
- * How a state is written after the selector it modifies: its pseudo-class — or, for `hidden`, the class that hides, and
- * for `current`, the attribute a link to this page carries.
+ * What the `current` state selects: whatever says it is the chosen one of its set — a link to the page being shown or
+ * any other `aria-current` but `false`, a pressed toggle, a selected tab, and the tab panel on show (the SDK hides the
+ * others with `hidden`). `aria-pressed="false"` on the options not chosen is what keeps them out.
+ *
+ * Its heaviest alternative weighs two attributes, so a class's `current` (0,3,0) wins over its `hover` (0,2,0) wherever
+ * they are written: a new alternative must weigh no more than that, or every `current` rule gets heavier with it.
+ */
+export declare const CURRENT_SELECTOR = ":is([aria-current]:not([aria-current=\"false\"]),[aria-pressed=\"true\"],[aria-selected=\"true\"],[role=\"tabpanel\"]:not([hidden]))";
+/** What the `expanded` state selects: the control whose panel is open. */
+export declare const EXPANDED_SELECTOR = "[aria-expanded=\"true\"]";
+/**
+ * How a state is written after the selector it modifies: its pseudo-class — or, for `hidden`, the class that hides; for
+ * `current` and `expanded`, the attributes the element carries; for where it sits, the structural pseudo-class.
  */
 export declare const stateSuffix: (state: string) => string;
 /**
@@ -37,3 +53,14 @@ export declare const stateSuffix: (state: string) => string;
  * fades out to nothing fades in from it — and every pseudo-class is not.
  */
 export declare const isStartingState: (state: string) => boolean;
+/**
+ * The `ancestors` key of the element right around this one — its parent — whatever class it wears, or none.
+ *
+ * What a closed component's part reacts to: the icon inside a button turning while the button is `expanded`, a label
+ * lit while its link is `current`. Only the parent, never "any ancestor": every ancestor of a hovered element is
+ * hovered too, up to `<body>`, so a condition on "an ancestor in a state" without naming it would always hold. Written
+ * `:where(:state) > &` — one step up, no `:has()`. It takes states only: "inside a parent" with no state is always.
+ * Authored as `parent`; a class name can never be `>`, so the key cannot meet a class.
+ */
+export declare const PARENT_ANCESTOR = ">";
+export declare const isParentAncestor: (ancestor: string) => boolean;

package/dist/style/styleStates.mjs

@@ -9,7 +9,12 @@ var e = [
 	"checked",
 	"visited",
 	"current",
-	"hidden"
+	"expanded",
+	"hidden",
+	"first",
+	"last",
+	"odd",
+	"even"
 ], t = "plitzi-component--hidden", n = {
 	hover: "Hover",
 	focus: "Focus",
@@ -19,19 +24,37 @@ var e = [
 	disabled: "Disabled",
 	checked: "Checked",
 	visited: "Visited",
-	current: "Current page",
-	hidden: "Hidden"
+	current: "Current",
+	expanded: "Expanded",
+	hidden: "Hidden",
+	first: "First child",
+	last: "Last child",
+	odd: "Odd child",
+	even: "Even child"
 }, r = {
-	visited: 0,
-	checked: 1,
-	current: 2,
-	"focus-within": 3,
-	hover: 4,
-	focus: 5,
-	"focus-visible": 6,
-	active: 7,
-	disabled: 8,
-	hidden: 9
-}, i = (e) => Object.hasOwn(r, e), a = (t) => i(t) ? r[t] : e.length, o = (e) => Object.entries(e).sort(([e], [t]) => a(e) - a(t)), s = "[aria-current=\"page\"]", c = (e) => e === "hidden" ? `.${t}` : e === "current" ? s : `:${e}`, l = (e) => e === "hidden";
+	odd: 0,
+	even: 1,
+	first: 2,
+	last: 3,
+	visited: 4,
+	checked: 5,
+	current: 6,
+	expanded: 7,
+	"focus-within": 8,
+	hover: 9,
+	focus: 10,
+	"focus-visible": 11,
+	active: 12,
+	disabled: 13,
+	hidden: 14
+}, i = (e) => Object.hasOwn(r, e), a = (t) => i(t) ? r[t] : e.length, o = (e) => Object.entries(e).sort(([e], [t]) => a(e) - a(t)), s = ":is([aria-current]:not([aria-current=\"false\"]),[aria-pressed=\"true\"],[aria-selected=\"true\"],[role=\"tabpanel\"]:not([hidden]))", c = "[aria-expanded=\"true\"]", l = {
+	current: s,
+	expanded: c,
+	hidden: `.${t}`,
+	first: ":first-child",
+	last: ":last-child",
+	odd: ":nth-child(odd)",
+	even: ":nth-child(even)"
+}, u = (e) => (i(e) ? l[e] : void 0) ?? `:${e}`, d = (e) => e === "hidden", f = ">", p = (e) => e === ">";
 //#endregion
-export { s as CURRENT_PAGE_SELECTOR, t as HIDDEN_CLASS, e as STYLE_STATES, n as STYLE_STATE_LABELS, o as inCascadeOrder, i as isKnownState, l as isStartingState, c as stateSuffix };
+export { s as CURRENT_SELECTOR, c as EXPANDED_SELECTOR, t as HIDDEN_CLASS, f as PARENT_ANCESTOR, e as STYLE_STATES, n as STYLE_STATE_LABELS, o as inCascadeOrder, i as isKnownState, p as isParentAncestor, d as isStartingState, u as stateSuffix };

package/dist/style/styleTarget.d.ts

@@ -0,0 +1,23 @@
+import { StyleBlock, StyleObject, StyleTarget } from '../types/StyleTypes';
+/**
+ * Where in a selector's block an edit lands, read the same way by the store that writes it, the inspector that shows
+ * it and the inheritance that explains it — once, here, rather than once in each.
+ *
+ * The keys are walked by hand, not through a dotted path: an ancestor key (`>`) and a condition key
+ * (`container (max-width: 30.5rem)`) are not path segments any path parser accepts, and must not have to be.
+ */
+/** The keys from a selector's block down to the rules a target addresses — `['variants', 'primary', 'states', 'hover']`. */
+export declare const styleTargetKeys: (target: StyleTarget) => string[];
+/**
+ * Why a target names no place a block has, or `undefined` when it names one: an ancestor's rules are not under a
+ * condition and draw no pseudo-element, a condition has no variants, and the parent (`>`) wears no variant.
+ */
+export declare const styleTargetProblem: (target: StyleTarget) => string | undefined;
+/** The value at `keys` under `root`, or `undefined` where any step is missing. */
+export declare const valueAtKeys: (root: unknown, keys: readonly string[]) => unknown;
+/** Writes `value` at `keys` under `root`, making every object on the way that is missing. */
+export declare const setAtKeys: (root: Record<string, unknown>, keys: readonly string[], value: unknown) => void;
+/** Whether a value is one set of rules: properties with a string or a number each. */
+export declare const isStyleRules: (value: unknown) => value is StyleObject;
+/** The rules a target addresses in a block, or `undefined` when the block has none there. */
+export declare const styleTargetRules: (block: StyleBlock | undefined, target: StyleTarget) => StyleObject | undefined;

package/dist/style/styleTarget.mjs

@@ -0,0 +1,35 @@
+import { canonicalCondition as e } from "./styleConditions.mjs";
+import { isStylePseudo as t } from "./stylePseudos.mjs";
+import { isParentAncestor as n } from "./styleStates.mjs";
+//#region src/style/styleTarget.ts
+var r = (e) => {
+	let t = [];
+	return e.styleAncestor ? t.push("ancestors", e.styleAncestor) : e.styleCondition && t.push("conditions", e.styleCondition), e.styleVariant && t.push("variants", e.styleVariant), e.stylePseudo && t.push("pseudos", e.stylePseudo), t.push(...e.styleState ? ["states", e.styleState] : ["default"]), t;
+}, i = (r) => {
+	if (r.styleAncestor && r.styleCondition) return "an ancestor condition cannot also be under a condition";
+	if (r.styleAncestor && r.stylePseudo) return "a pseudo-element has no ancestor conditions of its own";
+	if (r.styleCondition && r.styleVariant) return "a condition holds the class’s own rules, not its variants’";
+	if (r.styleCondition && e(r.styleCondition) !== r.styleCondition) return `"${r.styleCondition}" is not a condition`;
+	if (r.stylePseudo && !t(r.stylePseudo)) return `"${String(r.stylePseudo)}" is not a pseudo-element`;
+	if (r.styleAncestor && n(r.styleAncestor) && r.styleVariant) return "the element around it is named by its state, never by a variant";
+}, a = (e) => typeof e == "object" && !!e && !Array.isArray(e), o = (e, t) => {
+	let n = e;
+	for (let e of t) {
+		if (!a(n) || !Object.hasOwn(n, e)) return;
+		n = n[e];
+	}
+	return n;
+}, s = (e, t, n) => {
+	let r = e;
+	t.slice(0, -1).forEach((e) => {
+		let t = r[e], n = a(t) ? t : {};
+		r[e] = n, r = n;
+	});
+	let i = t.at(-1);
+	i !== void 0 && (r[i] = n);
+}, c = (e) => a(e) && Object.values(e).every((e) => typeof e == "string" || typeof e == "number"), l = (e, t) => {
+	let n = o(e, r(t));
+	return c(n) ? n : void 0;
+};
+//#endregion
+export { c as isStyleRules, s as setAtKeys, r as styleTargetKeys, i as styleTargetProblem, l as styleTargetRules, o as valueAtKeys };

package/dist/types/AuthTypes.d.ts

@@ -77,6 +77,11 @@ export type AuthContextValue = {
     /** Report that the backend refused a credential — the `reason` from a 401. `expired` triggers a silent renewal,
      *  anything terminal ends the session. This is how an app tells auth that reality moved on between checks. */
     invalidate: (reason?: AuthFailureReason) => void;
+    /**
+     * The provider this page signs in with: the space's `userProvider`, else the one the server that rendered it serves
+     * (`server.auth`). Empty when there is neither, and then a page offers no auth actions at all.
+     */
+    provider: string;
     state: AuthState;
     authenticated: boolean;
     user?: {

package/dist/types/CommonTypes.d.ts

@@ -1,5 +1,6 @@
 import { User } from './AuthTypes';
 import { RealtimeTransport } from './RealtimeTypes';
+import { Schema } from './SchemaTypes';
 import { SSRRenderResult, SSRRscData } from './ServerTypes';
 export type Environment = 'production' | 'staging' | 'development' | 'main';
 export type Server<T extends Record<string, unknown> = Record<string, unknown>> = {
@@ -30,8 +31,19 @@ export type Server<T extends Record<string, unknown> = Record<string, unknown>>
         /** Unix seconds the session token dies at, so a hydrated page schedules its renewal without decoding anything. */
         expiresAt?: number;
     };
+    /**
+     * How the server that rendered this page signs people in — see {@link ServerAuth}. Absent when it serves no
+     * sign-in of its own, and then only what the space declares counts.
+     */
+    auth?: ServerAuth;
     ssr?: ServerSSR;
 } & T;
+/**
+ * The sign-in a page server serves, in the terms of the space settings it stands in for: a space that declares no
+ * `userProvider` signs in here, with nothing to declare. Whatever a space does declare wins, and a space that names
+ * another provider ignores this entirely — it describes a different backend.
+ */
+export type ServerAuth = Required<Pick<Schema['settings'], 'userProvider' | 'loginUrl'>> & Pick<Schema['settings'], 'userUrl' | 'refreshUrl' | 'logoutUrl' | 'mfaUrl' | 'sessionHintCookie'>;
 /** What the rendering server hands over for THIS render, consumed once at the SDK root and not read from here again:
  *  the RSC bootstrap is projected into the store (`rsc`), which is where the live payload lives from then on. The
  *  rest of `Server` is long-lived configuration — endpoints, session — and stays readable anywhere. */

package/dist/types/SchemaTypes.d.ts

@@ -152,6 +152,8 @@ type SchemaVariableBase<TType extends string, TValue> = {
     }[];
 };
 export type SchemaVariable = SchemaVariableBase<'number', number> | SchemaVariableBase<'checkbox' | 'switch', boolean> | SchemaVariableBase<'text' | 'email' | 'password' | 'select' | 'select2' | 'textarea' | 'color', string>;
+/** What a variable holds once resolved: a number, a switch's state or text. */
+export type SchemaVariableValue = SchemaVariable['value'];
 /** A value a flag takes where its `when` matches. The first rule that matches decides. */
 export type SchemaFlagRule = {
     when: RuleGroup;

package/dist/types/ServerTypes.d.ts

@@ -1,5 +1,5 @@
 import { ActionEmailConfig, ActionEntry, ActionJobQueue, ActionLimits, ActionRejectReason, ActionRunSummary, ActionRejectRecord, ActionRunRecord, ActionRunReport, ActionRunStatus, ActionTaskDescriptor, ActionTriggerType } from './ActionTypes';
-import { Environment } from './CommonTypes';
+import { Environment, ServerAuth } from './CommonTypes';
 import { PluginDeclaration } from './ComponentTypes';
 import { ConnectorEntry } from './ConnectorTypes';
 import { DataDraft, DataSaveResult } from './DataTypes';
@@ -580,7 +580,7 @@ export type ActionLookupsConfig = {
     /**
      * The space's own data as of that revision — what a project keeps in `src/data/`, kept privately and frozen with each
      * publish — as its files' text by path (`products.json`). A provider resolved on the server whose `query` is
-     * `/data/<file>` reads it, as `dataDir` reads a folder; no browser is answered it.
+     * `/data/<file>` reads it, and a function's `ctx.data`; no browser is answered it. Given none, `dataDir` is read.
      */
     getData?: (spaceId: number, at?: SpaceRevision) => Promise<unknown>;
     /** The feature flags the space declares as of that revision — what a flow reads as `{{ flags.<name> }}`. */
@@ -938,7 +938,8 @@ export type SSRServerConfig = {
      * The project's own data, never served as files: a provider resolved on the server (`runtime: 'server'`) whose
      * `query` is `/data/<file>` reads `<dataDir>/<file>`, and the page arrives with it. Nobody downloads the folder; what
      * a provider reads goes into the page it renders, though — data a page must not carry is a server action's to read,
-     * answering only what is shown.
+     * answering only what is shown: a function reads it with `ctx.data('<file>')`. It is the space's data lookup
+     * (`action.lookups.getData`) when the deployment gives none.
      */
     dataDir?: string;
     static?: Record<string, string>;
@@ -978,6 +979,12 @@ export type SSRServerConfig = {
      * only with the `exchangeCredential` adapter, which is what turns what comes back into a session on this host.
      */
     signIn?: SSRSignInConfig;
+    /**
+     * The sign-in this server's pages are told about (`server.auth`), so a space that declares no `userProvider` signs
+     * in with nothing to declare. `createServer({ auth })` fills it from the kernel's `basePath`; name it yourself when
+     * the `/auth` flows are served by another host. The session hint cookie is added per request, named for the host.
+     */
+    pageAuth?: Omit<ServerAuth, 'sessionHintCookie'>;
     /** Naming and scope of the session cookies this server writes. See {@link SSRAuthCookie}. */
     authCookie?: SSRAuthCookie;
     templateFn?: SSRTemplateFn;
@@ -1183,7 +1190,7 @@ export type SSRServer = {
     readonly plugins: PluginRegistry;
     /**
      * With `devReload` on, every page open on this server loads again — what a project that authors its space in code
-     * calls once it wrote the new documents, instead of restarting the server. Nothing otherwise.
+     * calls once it serves the new documents (`serveProject`), instead of restarting the server. Nothing otherwise.
      */
     reloadPages: () => void;
     /**

package/dist/types/StoreTypes.d.ts

@@ -6,7 +6,7 @@ import { QueryParams, RouteParams } from './NavigationTypes';
 import { RealtimeTransport } from './RealtimeTypes';
 import { Schema, Element } from './SchemaTypes';
 import { SpaceConnector } from './SpaceTypes';
-import { DisplayMode, Style, StyleState } from './StyleTypes';
+import { DisplayMode, Style, StylePseudo, StyleState } from './StyleTypes';
 import { ColorScheme, Theme } from './ThemeTypes';
 import { FlagOverrides, FlagResolution } from '../flags/resolveFlags';
 export type RuntimeSourceValues = {
@@ -259,6 +259,10 @@ export type BuilderState = CommonState & {
     styleState?: StyleState;
     /** The ancestor class being edited under: `styleState`/`styleVariant` are then its, and neither means always. */
     styleAncestor?: string;
+    /** The pseudo-element being edited (`before`, `placeholder`…) of whatever the other fields address. */
+    stylePseudo?: StylePseudo;
+    /** The condition being edited under (`motion-reduce`, a container query): the class's own rules, there. */
+    styleCondition?: string;
     elementHovered?: string;
     elementSelected?: string;
     /**

package/dist/types/StyleTypes.d.ts

@@ -1,5 +1,6 @@
 import { ColorScheme, Theme } from './ThemeTypes';
 import { default as styleConstants } from '../style/styleConstants';
+import { StylePseudo } from '../style/stylePseudos';
 import { STYLE_STATES } from '../style/styleStates';
 export type TagType = 'class' | 'element' | 'id';
 export type DisplayMode = 'desktop' | 'tablet' | 'mobile';
@@ -20,18 +21,33 @@ export type StyleVariableGroup = Record<string, StyleVariableValue>;
 export type StyleVariables = Record<StyleVariableCategory, StyleVariableGroup>;
 export type StyleObject = Partial<Record<StyleCategory, StyleValue>>;
 export type StyleStates = Partial<Record<StyleState, StyleObject>>;
-export type StyleVariants = Record<string, Omit<StyleBlock, 'variants' | 'ancestors'>>;
+export type StyleStateBlock = {
+    default?: StyleObject;
+    states?: StyleStates;
+};
+export type { StylePseudo };
+export type StylePseudos = Partial<Record<StylePseudo, StyleStateBlock>>;
+export type StyleVariant = StyleStateBlock & {
+    pseudos?: StylePseudos;
+};
+export type StyleVariants = Record<string, StyleVariant>;
 export type StyleAncestor = {
     default?: StyleObject;
     states?: StyleStates;
-    variants?: StyleVariants;
+    variants?: Record<string, StyleStateBlock>;
 };
 export type StyleAncestors = Record<string, StyleAncestor>;
+export type StyleCondition = StyleStateBlock & {
+    pseudos?: StylePseudos;
+};
+export type StyleConditions = Record<string, StyleCondition>;
 export type StyleBlock = {
     default?: StyleObject;
     states?: StyleStates;
     variants?: StyleVariants;
     ancestors?: StyleAncestors;
+    pseudos?: StylePseudos;
+    conditions?: StyleConditions;
 };
 export type StyleTarget = {
     componentType?: string;
@@ -39,6 +55,8 @@ export type StyleTarget = {
     styleState?: StyleState;
     styleVariant?: string;
     styleAncestor?: string;
+    stylePseudo?: StylePseudo;
+    styleCondition?: string;
 };
 export type StyleAttributes = Record<string, StyleBlock>;
 export type StyleItem = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plitzi/sdk-shared",
-  "version": "0.38.5",
+  "version": "0.38.7",
   "license": "AGPL-3.0",
   "files": [
     "dist",
@@ -186,6 +186,10 @@
       "types": "./dist/dataSource/hooks/useRegisterSource.d.ts",
       "import": "./dist/dataSource/hooks/useRegisterSource.mjs"
     },
+    "./dataSource/hooks/useResolvedVariables": {
+      "types": "./dist/dataSource/hooks/useResolvedVariables.d.ts",
+      "import": "./dist/dataSource/hooks/useResolvedVariables.mjs"
+    },
     "./dataSource/index": {
       "types": "./dist/dataSource/index.d.ts",
       "import": "./dist/dataSource/index.mjs"
@@ -1099,6 +1103,18 @@
       "types": "./dist/plugins/declaration.d.ts",
       "import": "./dist/plugins/declaration.mjs"
     },
+    "./project/layout": {
+      "types": "./dist/project/layout.d.ts",
+      "import": "./dist/project/layout.mjs"
+    },
+    "./project/paths": {
+      "types": "./dist/project/paths.d.ts",
+      "import": "./dist/project/paths.mjs"
+    },
+    "./project/root": {
+      "types": "./dist/project/root.d.ts",
+      "import": "./dist/project/root.mjs"
+    },
     "./queries": {
       "types": "./dist/queries/index.d.ts",
       "import": "./dist/queries/index.mjs"
@@ -1111,10 +1127,18 @@
       "types": "./dist/queries/queryCache.d.ts",
       "import": "./dist/queries/queryCache.mjs"
     },
+    "./queries/serverQueries": {
+      "types": "./dist/queries/serverQueries.d.ts",
+      "import": "./dist/queries/serverQueries.mjs"
+    },
     "./queries/useQuery": {
       "types": "./dist/queries/useQuery.d.ts",
       "import": "./dist/queries/useQuery.mjs"
     },
+    "./queries/useServerQuery": {
+      "types": "./dist/queries/useServerQuery.d.ts",
+      "import": "./dist/queries/useServerQuery.mjs"
+    },
     "./realtime": {
       "types": "./dist/realtime/index.d.ts",
       "import": "./dist/realtime/index.mjs"
@@ -1359,6 +1383,10 @@
       "types": "./dist/style/index.d.ts",
       "import": "./dist/style/index.mjs"
     },
+    "./style/keyframes": {
+      "types": "./dist/style/keyframes.d.ts",
+      "import": "./dist/style/keyframes.mjs"
+    },
     "./style/layoutGrid": {
       "types": "./dist/style/layoutGrid.d.ts",
       "import": "./dist/style/layoutGrid.mjs"
@@ -1375,14 +1403,26 @@
       "types": "./dist/style/snippetStyle.d.ts",
       "import": "./dist/style/snippetStyle.mjs"
     },
+    "./style/styleConditions": {
+      "types": "./dist/style/styleConditions.d.ts",
+      "import": "./dist/style/styleConditions.mjs"
+    },
     "./style/styleConstants": {
       "types": "./dist/style/styleConstants.d.ts",
       "import": "./dist/style/styleConstants.mjs"
     },
+    "./style/stylePseudos": {
+      "types": "./dist/style/stylePseudos.d.ts",
+      "import": "./dist/style/stylePseudos.mjs"
+    },
     "./style/styleStates": {
       "types": "./dist/style/styleStates.d.ts",
       "import": "./dist/style/styleStates.mjs"
     },
+    "./style/styleTarget": {
+      "types": "./dist/style/styleTarget.d.ts",
+      "import": "./dist/style/styleTarget.mjs"
+    },
     "./style/useDisplayMode": {
       "types": "./dist/style/useDisplayMode.d.ts",
       "import": "./dist/style/useDisplayMode.mjs"
@@ -1532,7 +1572,7 @@
   },
   "dependencies": {
     "@plitzi/nexus": "^1.4.0",
-    "@plitzi/plitzi-ui": "^1.6.31",
+    "@plitzi/plitzi-ui": "^1.6.32",
     "date-fns": "^4.4.0",
     "immer": "^11.1.21",
     "zod": "^4.6.5"