@salsita-ai/sdk 0.50.0-develop.c28cfb7ded → 0.50.0-develop.c402728d10

package/dist/react-sdk/application-runtime/hooks/responsive/use-responsive-application.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The selectors and actions of the responsive state of the application this component is mounted
+ * in, chosen by its `ApplicationTypeProvider` as the domain context hooks choose theirs.
+ */
+export declare const useResponsiveApplication: () => {
+    runtime: import("../../index.js").ApplicationRuntime;
+    selectors: {
+        selectResponsiveState: import("@salsita-ai/common/utils").Selector<import("../../responsive/selectors.js").ResponsiveSelectorState, import("../../index.js").ResponsiveState>;
+        selectViewportSize: import("@salsita-ai/common/utils").Selector<import("../../responsive/selectors.js").ResponsiveSelectorState, import("../../index.js").ResponsiveViewportSize>;
+        selectCanvasPadding: import("@salsita-ai/common/utils").Selector<import("../../responsive/selectors.js").ResponsiveSelectorState, import("../../index.js").CanvasPadding>;
+        getResponsiveState: () => import("../../index.js").ResponsiveState;
+        getViewportSize: () => import("../../index.js").ResponsiveViewportSize;
+        getCanvasPadding: () => import("../../index.js").CanvasPadding;
+    };
+    actions: {
+        setViewport: (viewport: import("../../index.js").ResponsiveViewport) => void;
+        setBreakpoints: (breakpoints: import("../../index.js").ResponsiveBreakpoints) => void;
+        setCanvasPadding: (canvasPadding: import("../../index.js").CanvasPadding) => void;
+        expand: () => void;
+        collapse: () => void;
+        hide: () => void;
+        show: () => void;
+        setAnimating: (isAnimating: boolean) => void;
+        reset: () => void;
+    };
+};

package/dist/react-sdk/application-runtime/hooks/responsive/use-responsive-application.js

@@ -0,0 +1 @@
+import{useApplicationRuntime as e,useApplicationType as s}from"../../provider/index.js";import{ApplicationType as o}from"../../runtime/index.js";export const useResponsiveApplication=()=>{let i=e();return s()===o.Admin?{runtime:i,selectors:i.selectors.responsive.admin,actions:i.actions.responsive.admin}:{runtime:i,selectors:i.selectors.responsive.configurator,actions:i.actions.responsive.configurator}};

package/dist/react-sdk/application-runtime/hooks/responsive/use-responsive-state.d.ts

@@ -0,0 +1,10 @@
+import type { ResponsiveState } from '../../responsive/index.js';
+/**
+ * The responsive state of the application this component is mounted in: the size classes of its root container, the
+ * canvas padding, and whether the container is expanded, hidden or animating. Re-renders when any
+ * of them changes, not on a resize within one size class.
+ *
+ * @internal Runtime plumbing for the SDK's own UI. A project layout uses `useActiveViewports()`
+ * from `@salsita-ai/sdk/react` and `useSceneSafeArea()` from `@salsita-ai/sdk/configurator`.
+ */
+export declare const useResponsiveState: () => ResponsiveState;

package/dist/react-sdk/application-runtime/hooks/responsive/use-responsive-state.js

@@ -0,0 +1 @@
+import{useApplicationRuntimeSelector as e}from"../use-application-runtime-selector.js";import{useResponsiveApplication as t}from"./use-responsive-application.js";export const useResponsiveState=()=>{let{selectors:s}=t();return e(s.getResponsiveState)};

package/dist/react-sdk/application-runtime/hooks/responsive/use-responsive-store.d.ts

@@ -0,0 +1,24 @@
+import type { CanvasPadding, ResponsiveActions, ResponsiveState, ResponsiveViewportSize } from '../../responsive/index.js';
+/**
+ * The runtime's responsive state in the shape `ResponsiveApplicationProvider` of
+ * `@salsita-ai/sdk/ui` takes as its `store`, which that package declares by shape because it imports
+ * no other SDK package.
+ *
+ * @internal Runtime plumbing for the SDK's own UI. A project layout uses `useActiveViewports()`
+ * from `@salsita-ai/sdk/react` and `useSceneSafeArea()` from `@salsita-ai/sdk/configurator`.
+ */
+export interface ResponsiveStore extends Omit<ResponsiveActions, 'reset'> {
+    /** Calls `onChange` after every change of the runtime; returns the unsubscribe. */
+    readonly subscribe: (onChange: () => void) => () => void;
+    readonly getState: () => ResponsiveState;
+    readonly getViewportSize: () => ResponsiveViewportSize;
+    readonly getCanvasPadding: () => CanvasPadding;
+}
+/**
+ * The responsive state of the application this component is mounted in, as the store its root
+ * container measures into and `useResponsive()` reads from. Stable for the runtime's lifetime.
+ *
+ * @internal Runtime plumbing for the SDK's own UI. A project layout uses `useActiveViewports()`
+ * from `@salsita-ai/sdk/react` and `useSceneSafeArea()` from `@salsita-ai/sdk/configurator`.
+ */
+export declare const useResponsiveStore: () => ResponsiveStore;

package/dist/react-sdk/application-runtime/hooks/responsive/use-responsive-store.js

@@ -0,0 +1 @@
+import{useMemo as e}from"react";import{useResponsiveApplication as t}from"./use-responsive-application.js";export const useResponsiveStore=()=>{let{runtime:s,selectors:i,actions:a}=t();return e(()=>({setViewport:a.setViewport,setBreakpoints:a.setBreakpoints,setCanvasPadding:a.setCanvasPadding,expand:a.expand,collapse:a.collapse,hide:a.hide,show:a.show,setAnimating:a.setAnimating,subscribe:s.subscribe,getState:i.getResponsiveState,getViewportSize:i.getViewportSize,getCanvasPadding:i.getCanvasPadding}),[s,i,a])};

package/dist/react-sdk/application-runtime/hooks/use-access-service.d.ts

@@ -6,6 +6,11 @@ interface AccessServiceProviderProps {
 }
 export declare const AccessServiceProvider: (props: AccessServiceProviderProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useProvidedAccessService: () => AccessService;
+/**
+ * The provided access service with `accessInfo.viewMode` set by the application's read-only rule,
+ * the domain-context selector `getIsViewMode`: the access opens the configuration for viewing only,
+ * or the host element is `readonly`. The assistant's `apply` follows the same selector.
+ */
 export declare const useAccessService: () => AccessService;
 export declare const useConfigurationId: () => string;
 export declare const useConfiguratorRawAccessService: () => AccessService | null;

package/dist/react-sdk/application-runtime/hooks/use-access-service.js

@@ -1 +1 @@
-import{jsx as e}from"react/jsx-runtime";import{createContext as s,useContext as c,useMemo as o}from"react";import{standardWebComponentProperties as r}from"#package/domain";import{useApplicationRuntime as t}from"../provider/index.js";import{useApplicationRuntimeSelector as i}from"./use-application-runtime-selector.js";import{useWebComponentPropertyValue as n}from"./use-web-component.js";let a=s(null);export const AccessServiceProvider=s=>e(a.Provider,{value:s.value,children:s.children});export const useProvidedAccessService=()=>{let e=c(a);if(null===e)throw Error("Access service not found! Render access-dependent hooks inside AccessServiceProvider.");return e};export const useAccessService=()=>{let e=n(r.readonly),s=useProvidedAccessService();return o(()=>({...s,accessInfo:{...s.accessInfo,viewMode:s.accessInfo.viewMode||e}}),[s,e])};export const useConfigurationId=()=>useProvidedAccessService().configurationId;export const useConfiguratorRawAccessService=()=>i(t().selectors.access.getConfiguratorRawAccessService);export const useAdminRawAccessService=()=>i(t().selectors.access.getAdminRawAccessService);export const useConfiguratorRawAccessInfo=()=>i(t().selectors.access.getConfiguratorRawAccessInfo);export const useAdminRawAccessInfo=()=>i(t().selectors.access.getAdminRawAccessInfo);export const useAccessInfoActions=()=>t().actions.access;
+import{jsx as e}from"react/jsx-runtime";import{createContext as s,useContext as c,useMemo as o}from"react";import{useApplicationRuntime as r,useApplicationType as t}from"../provider/index.js";import{ApplicationType as i}from"../runtime/index.js";import{useApplicationRuntimeSelector as n}from"./use-application-runtime-selector.js";let a=s(null);export const AccessServiceProvider=s=>e(a.Provider,{value:s.value,children:s.children});export const useProvidedAccessService=()=>{let e=c(a);if(null===e)throw Error("Access service not found! Render access-dependent hooks inside AccessServiceProvider.");return e};export const useAccessService=()=>{let e=t(),s=r(),c=useProvidedAccessService(),a=n(e===i.Admin?s.selectors.domainContext.admin.getIsViewMode:s.selectors.domainContext.configurator.getIsViewMode);return o(()=>({...c,accessInfo:{...c.accessInfo,viewMode:a}}),[c,a])};export const useConfigurationId=()=>useProvidedAccessService().configurationId;export const useConfiguratorRawAccessService=()=>n(r().selectors.access.getConfiguratorRawAccessService);export const useAdminRawAccessService=()=>n(r().selectors.access.getAdminRawAccessService);export const useConfiguratorRawAccessInfo=()=>n(r().selectors.access.getConfiguratorRawAccessInfo);export const useAdminRawAccessInfo=()=>n(r().selectors.access.getAdminRawAccessInfo);export const useAccessInfoActions=()=>r().actions.access;

package/dist/react-sdk/application-runtime/hooks/use-phoenix-element-slots.d.ts

@@ -1,8 +1,9 @@
-import type { PropsWithChildren } from 'react';
+import type { ComponentType, PropsWithChildren } from 'react';
 import type { CustomPhoenixEntityElementProps } from '#package/domain';
 export interface PhoenixElementSlots {
     readonly entityElements: Record<string, (props: CustomPhoenixEntityElementProps) => JSX.Element>;
     readonly layoutElements: Record<string, (props: PropsWithChildren) => JSX.Element>;
+    readonly assistantFormElements: Record<string, ComponentType<never>>;
     readonly hashes: Record<string, string>;
 }
 export declare const usePhoenixElementSlots: () => PhoenixElementSlots;

package/dist/react-sdk/application-runtime/hooks/use-web-component-readonly-sync.d.ts

@@ -1,15 +1,8 @@
 /**
- * Mirrors the host's `readonly` web-component property into runtime state, where the domain reads it
- * as part of the effective mode.
+ * Does nothing. The application runtime mirrors the host's `readonly` web-component property into
+ * runtime state itself, from its construction on, so no component has to.
  *
- * Call it once at the application root. The configurator does; the admin application deliberately
- * does not, because `readonly` is a property of the custom element a host embeds and admin is not
- * embedded that way.
- *
- * Root placement means a domain lifecycle mounting in the same commit can initialize before the
- * first value lands, since React runs child effects before parent effects. That is harmless: nothing
- * reads the effective mode while initializing — persistence reads it per save request, and the
- * domain context picks a later change up through the expression context, whose identity `reconcile`
- * compares on every runtime notification.
+ * @deprecated The runtime keeps `readonly` in sync without it; remove the call. This hook will be
+ * removed in a future version.
  */
 export declare const useWebComponentReadonlySync: () => void;

package/dist/react-sdk/application-runtime/hooks/use-web-component-readonly-sync.js

@@ -1 +1 @@
-import{useEffect as e}from"react";import{standardWebComponentProperties as o}from"#package/domain";import{useApplicationRuntime as r}from"../provider/index.js";import{useWebComponentProperty$ as n}from"./use-web-component.js";export const useWebComponentReadonlySync=()=>{let t=r(),m=n(o.readonly);e(()=>{let e=m.subscribe(t.actions.webComponent.setReadonly);return()=>{e.unsubscribe()}},[t,m])};
+export const useWebComponentReadonlySync=()=>{};

package/dist/react-sdk/application-runtime/hooks/use-web-component.d.ts

@@ -7,6 +7,11 @@ export declare const useWebComponentApi: () => WebComponentApi;
 export declare function useWebComponentProperty$<T>(property: WebComponentPropertyDescriptor<T>): BehaviorSubject<T>;
 export declare function useWebComponentPropertySetter<T>(property: WebComponentPropertyDescriptor<T>): Dispatch<SetStateAction<T>>;
 export declare const useWebComponentPropertyState: <T>(property: WebComponentPropertyDescriptor<T>) => [value: T, setValue: Dispatch<SetStateAction<T>>];
+/**
+ * The property's current value; re-renders when it changes. A standard property the runtime
+ * mirrors is read from the slice its scope names, `hostProperties` or the domain's `webComponent`;
+ * any other property from its storage.
+ */
 export declare const useWebComponentPropertyValue: <T>(property: WebComponentPropertyDescriptor<T>) => T;
 export declare const useDispatchWebComponentEvent: <T, R>(event: WebComponentEventDescriptor<T, R>) => (payload: T) => Promise<R | undefined>;
 export declare const useWebcomponentGeneration: () => number;

package/dist/react-sdk/application-runtime/hooks/use-web-component.js

@@ -1 +1 @@
-import{useCallback as e}from"react";import{useEagerObservableValue as o}from"../../domain-context/common-hooks/use-observable-selector.js";import{useApplicationRuntime as t}from"../provider/index.js";import{useApplicationRuntimeSelector as n}from"./use-application-runtime-selector.js";export const useWebComponentOptions=()=>t().selectors.commonServices.getWebComponentOptions();export const useWebComponentApi=()=>t().selectors.commonServices.getWebComponentApi();export function useWebComponentProperty$(e){return useWebComponentApi().getPropertyStorage(e).subject}export function useWebComponentPropertySetter(o){let t=useWebComponentProperty$(o);return e(e=>{let o="function"==typeof e?e(t.value):e;o!==t.value&&t.next(o)},[t])}export const useWebComponentPropertyState=e=>{let t=useWebComponentProperty$(e),n=useWebComponentPropertySetter(e);return[o(t),n]};export const useWebComponentPropertyValue=e=>o(useWebComponentProperty$(e));export const useDispatchWebComponentEvent=o=>{let t=useWebComponentApi();return e(async e=>t.dispatchEvent(o,e),[o,t])};export const useWebcomponentGeneration=()=>n(t().selectors.webComponent.getWebcomponentGeneration);
+import{useCallback as e}from"react";import{useEagerObservableValue as o}from"../../domain-context/common-hooks/use-observable-selector.js";import{findMirroredHostPropertyReader as t}from"../host-properties/index.js";import{useApplicationRuntime as n}from"../provider/index.js";import{useApplicationRuntimeSelector as r}from"./use-application-runtime-selector.js";export const useWebComponentOptions=()=>n().selectors.commonServices.getWebComponentOptions();export const useWebComponentApi=()=>n().selectors.commonServices.getWebComponentApi();export function useWebComponentProperty$(e){return useWebComponentApi().getPropertyStorage(e).subject}export function useWebComponentPropertySetter(o){let t=useWebComponentProperty$(o);return e(e=>{let o="function"==typeof e?e(t.value):e;o!==t.value&&t.next(o)},[t])}export const useWebComponentPropertyState=e=>[useWebComponentPropertyValue(e),useWebComponentPropertySetter(e)];export const useWebComponentPropertyValue=e=>{let p=n(),s=useWebComponentProperty$(e),m=t(e),u=o(s,null===m);return r(()=>null===m?u:m(p.selectors))};export const useDispatchWebComponentEvent=o=>{let t=useWebComponentApi();return e(async e=>t.dispatchEvent(o,e),[o,t])};export const useWebcomponentGeneration=()=>r(n().selectors.webComponent.getWebcomponentGeneration);

package/dist/react-sdk/application-runtime/host-properties/actions.d.ts

@@ -0,0 +1,15 @@
+import type { HostPropertyName } from './host-property-scopes.js';
+import type { HostPropertiesState, HostPropertyValue } from './types.js';
+interface Context {
+    readonly setHostProperties: (update: (state: HostPropertiesState) => HostPropertiesState) => void;
+}
+/**
+ * Internal to the runtime: only the subscription `connectHostProperties` sets up calls these. The
+ * runtime does not expose them on `actions`, because the host writes properties through the
+ * element.
+ */
+export declare const createHostPropertiesActions: (context: Context) => {
+    setHostProperty: <NAME extends HostPropertyName>(name: NAME, value: HostPropertyValue<NAME>) => void;
+};
+export type HostPropertiesActions = ReturnType<typeof createHostPropertiesActions>;
+export {};

package/dist/react-sdk/application-runtime/host-properties/actions.js

@@ -0,0 +1 @@
+import{isShallowEqual as t}from"@salsita-ai/common/utils";export const createHostPropertiesActions=o=>{let{setHostProperties:r}=o;return{setHostProperty:(o,e)=>{r(r=>t(r[o],e)?r:{...r,[o]:e})}}};

package/dist/react-sdk/application-runtime/host-properties/connect-host-properties.d.ts

@@ -0,0 +1,30 @@
+import type { WebComponentHostActions, WebComponentSelectors } from '#package/domain';
+import type { WebComponentApi } from '../web-component/index.js';
+import type { HostPropertiesActions } from './actions.js';
+interface Context {
+    readonly webComponentApi: WebComponentApi;
+    readonly actions: HostPropertiesActions;
+    /** The domain's `webComponent` slice, which keeps the domain-scoped properties. */
+    readonly domainSelectors: WebComponentSelectors;
+    readonly domainActions: WebComponentHostActions;
+}
+/**
+ * The runtime-owned subscription behind the mirrored host properties: mirrors each mirrored
+ * property storage of the element into the slice its scope names, the application-scoped ones
+ * into `hostProperties` and the domain-scoped ones into the domain's `webComponent`. Either slice
+ * publishes only when a value changes, equal meaning shallowly equal.
+ *
+ * The runtime calls it once, right after its subject exists, and keeps it for its whole lifetime,
+ * as long as the element that owns the storages. The storages are `BehaviorSubject`s, so the first
+ * emissions replay the values the slices were initialized with and publish nothing, except a
+ * domain-scoped property the host set before the runtime existed. The admin application gets the
+ * domain-scoped properties too: its element never sets `readonly`, so the value stays `false`.
+ *
+ * Interim: the element's property storages are still the store and these slices a read mirror,
+ * so every mirrored value is held twice. CON-3142 makes the slice the only store (the element's
+ * setters and attribute parsing write it) and removes the storages and this subscription.
+ *
+ * @returns the unsubscribe, for tests and runtimes that end before their element.
+ */
+export declare const connectHostProperties: (context: Context) => (() => void);
+export {};

package/dist/react-sdk/application-runtime/host-properties/connect-host-properties.js

@@ -0,0 +1 @@
+import{isShallowEqual as r}from"@salsita-ai/common/utils";import{getDomainHostProperty as o,setDomainHostProperty as t}from"./domain-host-properties.js";import{hostPropertyDescriptors as s}from"./host-property-descriptors.js";import{domainHostPropertyNames as e,hostPropertyNames as p}from"./host-property-scopes.js";export const connectHostProperties=i=>{let{webComponentApi:m,actions:c,domainSelectors:a,domainActions:b}=i,u=[...p.map(r=>m.getPropertyStorage(s[r]).subject.subscribe(o=>{c.setHostProperty(r,o)})),...e.map(e=>m.getPropertyStorage(s[e]).subject.subscribe(s=>{r(o(a,e),s)||t(b,e,s)}))];return()=>{u.forEach(r=>{r.unsubscribe()})}};

package/dist/react-sdk/application-runtime/host-properties/domain-host-properties.d.ts

@@ -0,0 +1,7 @@
+import type { WebComponentHostActions, WebComponentSelectors } from '#package/domain';
+import type { DomainHostPropertyName } from './host-property-scopes.js';
+import type { HostPropertyValue } from './types.js';
+/** A domain-scoped property's current value in the domain's `webComponent` slice. */
+export declare const getDomainHostProperty: <NAME extends DomainHostPropertyName>(selectors: WebComponentSelectors, name: NAME) => HostPropertyValue<NAME>;
+/** Writes a domain-scoped property into the domain's `webComponent` slice. */
+export declare const setDomainHostProperty: <NAME extends DomainHostPropertyName>(actions: WebComponentHostActions, name: NAME, value: HostPropertyValue<NAME>) => void;

package/dist/react-sdk/application-runtime/host-properties/domain-host-properties.js

@@ -0,0 +1 @@
+let e={readonly:{get:e=>e.getReadonly(),set:(e,t)=>{e.setReadonly(t)}},locale:{get:e=>e.getLocale(),set:(e,t)=>{e.setLocale(t)}}};export const getDomainHostProperty=(t,o)=>e[o].get(t);export const setDomainHostProperty=(t,o,s)=>{e[o].set(t,s)};

package/dist/react-sdk/application-runtime/host-properties/host-property-descriptors.d.ts

@@ -0,0 +1,21 @@
+import { type WebComponentPropertyDescriptor, type WebComponentSelectors } from '#package/domain';
+import { type MirroredHostPropertyName } from './host-property-scopes.js';
+import type { HostPropertiesSelectors } from './selectors.js';
+import type { HostPropertyValue } from './types.js';
+export declare const hostPropertyDescriptors: {
+    readonly [NAME in MirroredHostPropertyName]: WebComponentPropertyDescriptor<HostPropertyValue<NAME>>;
+};
+/** The runtime selectors of the two slices that keep mirrored properties. */
+interface MirroredHostPropertySelectors {
+    readonly hostProperties: HostPropertiesSelectors;
+    readonly webComponent: WebComponentSelectors;
+}
+/** Reads a mirrored property's current value from the slice its scope names. */
+export type MirroredHostPropertyReader<T> = (selectors: MirroredHostPropertySelectors) => T;
+/**
+ * The reader of the mirrored property a descriptor stands for, or `null` when the runtime does not
+ * mirror it. The map keys each reader by its own descriptor, so a reader returns its descriptor's
+ * value type; a `Map` cannot state that per entry, so the overload states it once here.
+ */
+export declare function findMirroredHostPropertyReader<T>(descriptor: WebComponentPropertyDescriptor<T>): MirroredHostPropertyReader<T> | null;
+export {};

package/dist/react-sdk/application-runtime/host-properties/host-property-descriptors.js

@@ -0,0 +1 @@
+import{standardWebComponentProperties as e}from"#package/domain";import{getDomainHostProperty as o}from"./domain-host-properties.js";import{domainHostPropertyNames as r,hostPropertyNames as t}from"./host-property-scopes.js";export const hostPropertyDescriptors={route:e.route,expanded:e.expanded,mode:e.mode,power:e.power,presetTags:e.presetTags,locale:e.locale,readonly:e.readonly,integrationMode:e.integrationMode,sessionToken:e.sessionToken,adminSessionToken:e.adminSessionToken,refreshToken:e.refreshToken,authorizationCode:e.authorizationCode};let s=new Map([...t.map(e=>[hostPropertyDescriptors[e],o=>o.hostProperties.getHostProperty(e)]),...r.map(e=>[hostPropertyDescriptors[e],r=>o(r.webComponent,e)])]);export function findMirroredHostPropertyReader(e){return s.get(e)??null}

package/dist/react-sdk/application-runtime/host-properties/host-property-scopes.d.ts

@@ -0,0 +1,42 @@
+import { standardWebComponentProperties } from '#package/domain';
+/**
+ * Where the runtime keeps a standard web-component property's current value:
+ * - `element`: only on the element, read from its property storage.
+ * - `application`: mirrored into the application runtime's `hostProperties` slice.
+ * - `domain`: mirrored into the domain runtime's `webComponent` slice, for domain systems that
+ *   read it without the application runtime.
+ */
+type HostPropertyScope = 'element' | 'application' | 'domain';
+type StandardPropertyName = keyof typeof standardWebComponentProperties;
+declare const hostPropertyScopes: {
+    readonly readonly: 'domain';
+    readonly locale: 'domain';
+    readonly route: 'application';
+    readonly expanded: 'application';
+    readonly mode: 'application';
+    readonly power: 'application';
+    readonly presetTags: 'application';
+    readonly integrationMode: 'application';
+    readonly sessionToken: 'application';
+    readonly adminSessionToken: 'application';
+    readonly refreshToken: 'application';
+    readonly authorizationCode: 'application';
+    readonly onEvent: 'element';
+    readonly onAttached: 'element';
+    readonly nonce: 'element';
+    readonly modalZIndex: 'element';
+    readonly containerZIndex: 'element';
+    readonly htmlFontSize: 'element';
+};
+type ScopedPropertyName<SCOPE extends HostPropertyScope> = {
+    [NAME in StandardPropertyName]: (typeof hostPropertyScopes)[NAME] extends SCOPE ? NAME : never;
+}[StandardPropertyName];
+/** The name of a standard web-component property the runtime mirrors into `hostProperties`. */
+export type HostPropertyName = ScopedPropertyName<'application'>;
+/** The name of a standard web-component property the runtime mirrors into the domain's `webComponent`. */
+export type DomainHostPropertyName = ScopedPropertyName<'domain'>;
+/** The name of a standard web-component property the runtime mirrors, into either slice. */
+export type MirroredHostPropertyName = HostPropertyName | DomainHostPropertyName;
+export declare const hostPropertyNames: ScopedPropertyName<"application">[];
+export declare const domainHostPropertyNames: ScopedPropertyName<"domain">[];
+export {};

package/dist/react-sdk/application-runtime/host-properties/host-property-scopes.js

@@ -0,0 +1 @@
+import{standardWebComponentProperties as e}from"#package/domain";let o={readonly:"domain",locale:"domain",route:"application",expanded:"application",mode:"application",power:"application",presetTags:"application",integrationMode:"application",sessionToken:"application",adminSessionToken:"application",refreshToken:"application",authorizationCode:"application",onEvent:"element",onAttached:"element",nonce:"element",modalZIndex:"element",containerZIndex:"element",htmlFontSize:"element"},n=e=>n=>o[n]===e,t=Object.keys(e).filter(o=>Object.hasOwn(e,o));export const hostPropertyNames=t.filter(n("application"));export const domainHostPropertyNames=t.filter(n("domain"));

package/dist/react-sdk/application-runtime/host-properties/index.d.ts

@@ -0,0 +1,8 @@
+export * from './actions.js';
+export * from './connect-host-properties.js';
+export * from './domain-host-properties.js';
+export * from './host-property-descriptors.js';
+export * from './host-property-scopes.js';
+export * from './initialize.js';
+export * from './selectors.js';
+export type * from './types.js';

package/dist/react-sdk/application-runtime/host-properties/index.js

@@ -0,0 +1 @@
+export*from"./actions.js";export*from"./connect-host-properties.js";export*from"./domain-host-properties.js";export*from"./host-property-descriptors.js";export*from"./host-property-scopes.js";export*from"./initialize.js";export*from"./selectors.js";

package/dist/react-sdk/application-runtime/host-properties/initialize.d.ts

@@ -0,0 +1,7 @@
+import type { WebComponentApi } from '../web-component/index.js';
+import type { HostPropertiesState } from './types.js';
+/**
+ * The element's current property values. Without a web component the API's storages hold the
+ * defaults, so the slice does too.
+ */
+export declare const initializeHostProperties: (webComponentApi: WebComponentApi) => HostPropertiesState;

package/dist/react-sdk/application-runtime/host-properties/initialize.js

@@ -0,0 +1 @@
+import{hostPropertyDescriptors as e}from"./host-property-descriptors.js";export const initializeHostProperties=o=>{let r=r=>o.getPropertyValue(e[r]);return{route:r("route"),expanded:r("expanded"),mode:r("mode"),power:r("power"),presetTags:r("presetTags"),integrationMode:r("integrationMode"),sessionToken:r("sessionToken"),adminSessionToken:r("adminSessionToken"),refreshToken:r("refreshToken"),authorizationCode:r("authorizationCode")}};

package/dist/react-sdk/application-runtime/host-properties/selectors.d.ts

@@ -0,0 +1,54 @@
+import { type Selector } from '@salsita-ai/common/utils';
+import type { HostPropertyName } from './host-property-scopes.js';
+import type { HostPropertiesState } from './types.js';
+export interface HostPropertiesSelectorState {
+    readonly hostProperties: HostPropertiesState;
+}
+interface Context {
+    readonly getState: () => HostPropertiesSelectorState;
+}
+type HostPropertySelectors = {
+    readonly [NAME in HostPropertyName]: Selector<HostPropertiesSelectorState, HostPropertiesState[NAME]>;
+};
+export declare const createHostPropertiesSelectors: (context: Context) => {
+    getHostPropertySelector: <NAME extends HostPropertyName>(name: NAME) => HostPropertySelectors[NAME];
+    selectRoute: Selector<HostPropertiesSelectorState, {
+        route: "Index";
+    } | {
+        route: "Configuration";
+        configurationId: string;
+        accessToken?: string | undefined;
+    } | {
+        readonly route: "Index";
+    }>;
+    selectExpanded: Selector<HostPropertiesSelectorState, boolean>;
+    selectMode: Selector<HostPropertiesSelectorState, "admin" | "configurator" | "standalone-admin">;
+    selectPower: Selector<HostPropertiesSelectorState, "off" | "on" | "standby">;
+    selectPresetTags: Selector<HostPropertiesSelectorState, string[] | null>;
+    selectIntegrationMode: Selector<HostPropertiesSelectorState, "handoff" | "headless" | "page" | "widget">;
+    selectSessionToken: Selector<HostPropertiesSelectorState, string | undefined>;
+    selectAdminSessionToken: Selector<HostPropertiesSelectorState, string | undefined>;
+    selectRefreshToken: Selector<HostPropertiesSelectorState, string | undefined>;
+    selectAuthorizationCode: Selector<HostPropertiesSelectorState, string | undefined>;
+    getHostProperty: <NAME extends HostPropertyName>(name: NAME) => HostPropertiesState[NAME];
+    getRoute: () => {
+        route: "Index";
+    } | {
+        route: "Configuration";
+        configurationId: string;
+        accessToken?: string | undefined;
+    } | {
+        readonly route: "Index";
+    };
+    getExpanded: () => boolean;
+    getMode: () => "admin" | "configurator" | "standalone-admin";
+    getPower: () => "off" | "on" | "standby";
+    getPresetTags: () => string[] | null;
+    getIntegrationMode: () => "handoff" | "headless" | "page" | "widget";
+    getSessionToken: () => string | undefined;
+    getAdminSessionToken: () => string | undefined;
+    getRefreshToken: () => string | undefined;
+    getAuthorizationCode: () => string | undefined;
+};
+export type HostPropertiesSelectors = ReturnType<typeof createHostPropertiesSelectors>;
+export {};

package/dist/react-sdk/application-runtime/host-properties/selectors.js

@@ -0,0 +1 @@
+import{createSelector as e}from"@salsita-ai/common/utils";export const createHostPropertiesSelectors=o=>{let{getState:t}=o,s=e.withTypes(),r={route:s.leaf(e=>e.hostProperties.route),expanded:s.leaf(e=>e.hostProperties.expanded),mode:s.leaf(e=>e.hostProperties.mode),power:s.leaf(e=>e.hostProperties.power),presetTags:s.leaf(e=>e.hostProperties.presetTags),integrationMode:s.leaf(e=>e.hostProperties.integrationMode),sessionToken:s.leaf(e=>e.hostProperties.sessionToken),adminSessionToken:s.leaf(e=>e.hostProperties.adminSessionToken),refreshToken:s.leaf(e=>e.hostProperties.refreshToken),authorizationCode:s.leaf(e=>e.hostProperties.authorizationCode)},n=e=>r[e];return{getHostPropertySelector:n,selectRoute:r.route,selectExpanded:r.expanded,selectMode:r.mode,selectPower:r.power,selectPresetTags:r.presetTags,selectIntegrationMode:r.integrationMode,selectSessionToken:r.sessionToken,selectAdminSessionToken:r.adminSessionToken,selectRefreshToken:r.refreshToken,selectAuthorizationCode:r.authorizationCode,getHostProperty:e=>n(e)(t()),getRoute:()=>r.route(t()),getExpanded:()=>r.expanded(t()),getMode:()=>r.mode(t()),getPower:()=>r.power(t()),getPresetTags:()=>r.presetTags(t()),getIntegrationMode:()=>r.integrationMode(t()),getSessionToken:()=>r.sessionToken(t()),getAdminSessionToken:()=>r.adminSessionToken(t()),getRefreshToken:()=>r.refreshToken(t()),getAuthorizationCode:()=>r.authorizationCode(t())}};

package/dist/react-sdk/application-runtime/host-properties/types.d.ts

@@ -0,0 +1,18 @@
+import type { WebComponentPropertyDescriptor, standardWebComponentProperties } from '#package/domain';
+import type { HostPropertyName, MirroredHostPropertyName } from './host-property-scopes.js';
+type StandardWebComponentProperties = typeof standardWebComponentProperties;
+type PropertyValue<DESCRIPTOR> = DESCRIPTOR extends WebComponentPropertyDescriptor<infer T> ? T : never;
+/** The value type of a mirrored standard web-component property. */
+export type HostPropertyValue<NAME extends MirroredHostPropertyName> = PropertyValue<StandardWebComponentProperties[NAME]>;
+/**
+ * The current value of each application-scoped standard web-component property, as the host set
+ * it on the element, or the property's default. The domain-scoped ones, `readonly` and `locale`,
+ * live in the domain's `webComponent` slice instead.
+ *
+ * A read mirror: the element's property storage stays the single store, and writes keep going
+ * through the element setters.
+ */
+export type HostPropertiesState = {
+    readonly [NAME in HostPropertyName]: HostPropertyValue<NAME>;
+};
+export {};

package/dist/react-sdk/application-runtime/host-properties/types.js

@@ -0,0 +1 @@
+export{};

package/dist/react-sdk/application-runtime/index.d.ts

@@ -4,7 +4,10 @@ export * from './hooks/index.js';
 export * from './web-component/index.js';
 export * from './common-services/index.js';
 export * from './domain-application-context/index.js';
+export type { HostPropertiesState, HostPropertyName } from './host-properties/index.js';
 export * from './integration/index.js';
+export { type LoadingActions, type LoadingApplicationState, type LoadingPhase, type LoadingRuntimeState, type LoadingState, } from './loading/index.js';
+export { type CanvasPadding, type ResponsiveApplicationState, type ResponsiveBreakpoints, type ResponsiveRuntimeState, type ResponsiveState, type ResponsiveViewport, type ResponsiveViewportSize, } from './responsive/index.js';
 export * from './routing/index.js';
 export * from './session/index.js';
 export * from './mocks/index.js';

package/dist/react-sdk/application-runtime/integration/initialize.d.ts

@@ -1,7 +1,8 @@
-import type { IntegrationActions } from './actions.js';
 import type { IntegrationState } from './types.js';
-interface Context {
-    readonly actions: IntegrationActions;
-}
-export declare const initializeIntegration: (context: Context) => IntegrationState;
-export {};
+/**
+ * The integration slice's initial state. The admin integration service is not part of it: the
+ * integration selectors own it.
+ *
+ * @internal Runtime plumbing for the SDK's own UI.
+ */
+export declare const initializeIntegration: () => IntegrationState;

package/dist/react-sdk/application-runtime/integration/initialize.js

@@ -1 +1 @@
-import{AdminIntegrationService as e}from"./admin-integration-service.js";export const initializeIntegration=i=>{let{actions:n}=i;return{adminIntegrationService:new e({actions:n}),embeddedView:null}};
+export const initializeIntegration=()=>({embeddedView:null});

package/dist/react-sdk/application-runtime/integration/selectors.d.ts

@@ -1,17 +1,26 @@
+import type { IntegrationActions } from './actions.js';
+import { AdminIntegrationService } from './admin-integration-service.js';
 import type { IntegrationState } from './types.js';
 export interface IntegrationSelectorState {
     readonly integration: IntegrationState;
 }
 interface Context {
     readonly getState: () => IntegrationSelectorState;
+    /** The actions the selector-owned admin integration service calls. */
+    readonly actions: IntegrationActions;
 }
+/**
+ * The integration selectors. They own the runtime's admin integration service, built from the
+ * given actions.
+ *
+ * @internal Runtime plumbing for the SDK's own UI.
+ */
 export declare const createIntegrationSelectors: (context: Context) => {
-    selectAdminIntegrationService: import("@salsita-ai/common/utils").Selector<IntegrationSelectorState, import("./admin-integration-service.js").AdminIntegrationService>;
     selectIntegrationState: import("@salsita-ai/common/utils").Selector<IntegrationSelectorState, IntegrationState>;
     selectEmbeddedView: import("@salsita-ai/common/utils").Selector<IntegrationSelectorState, import("./types.js").EmbeddedView>;
     selectPresetEmbeddedState: import("@salsita-ai/common/utils").Selector<IntegrationSelectorState, import("./types.js").PresetEmbeddedView | null>;
     selectRecipeEmbeddedState: import("@salsita-ai/common/utils").Selector<IntegrationSelectorState, import("./types.js").RecipeEmbeddedView | null>;
-    getAdminIntegrationService: () => import("./admin-integration-service.js").AdminIntegrationService;
+    getAdminIntegrationService: () => AdminIntegrationService;
     getIntegrationState: () => IntegrationState;
     getEmbeddedView: () => import("./types.js").EmbeddedView;
     getPresetEmbeddedState: () => import("./types.js").PresetEmbeddedView | null;

package/dist/react-sdk/application-runtime/integration/selectors.js

@@ -1 +1 @@
-import{createSelector as e}from"@salsita-ai/common/utils";export const createIntegrationSelectors=t=>{let{getState:i}=t,n=e.withTypes(),r=n.leaf(e=>e.integration.adminIntegrationService),a=n.leaf(e=>e.integration),d=n.leaf(e=>e.integration.embeddedView),o=n([d],e=>e?.type==="recipe"?e:null),g=n([d],e=>e?.type==="preset"?e:null);return{selectAdminIntegrationService:r,selectIntegrationState:a,selectEmbeddedView:d,selectPresetEmbeddedState:g,selectRecipeEmbeddedState:o,getAdminIntegrationService:()=>r(i()),getIntegrationState:()=>a(i()),getEmbeddedView:()=>d(i()),getPresetEmbeddedState:()=>g(i()),getRecipeEmbeddedState:()=>o(i())}};
+import{createSelector as e}from"@salsita-ai/common/utils";import{AdminIntegrationService as t}from"./admin-integration-service.js";export const createIntegrationSelectors=i=>{let{getState:n,actions:r}=i,a=e.withTypes(),o=new t({actions:r}),d=a.leaf(e=>e.integration),m=a.leaf(e=>e.integration.embeddedView),g=a([m],e=>e?.type==="recipe"?e:null),l=a([m],e=>e?.type==="preset"?e:null);return{selectIntegrationState:d,selectEmbeddedView:m,selectPresetEmbeddedState:l,selectRecipeEmbeddedState:g,getAdminIntegrationService:()=>o,getIntegrationState:()=>d(n()),getEmbeddedView:()=>m(n()),getPresetEmbeddedState:()=>l(n()),getRecipeEmbeddedState:()=>g(n())}};

package/dist/react-sdk/application-runtime/integration/types.d.ts

@@ -1,5 +1,4 @@
 import type { DomainEntityId, Preset, Recipe } from '#package/domain';
-import type { AdminIntegrationService } from './admin-integration-service.js';
 export interface PresetEmbeddedView {
     readonly type: 'preset';
     readonly presetId: Preset['id'];
@@ -11,7 +10,11 @@ export interface RecipeEmbeddedView {
     readonly rootRecipeId?: DomainEntityId<string>;
 }
 export type EmbeddedView = PresetEmbeddedView | RecipeEmbeddedView | null;
+/**
+ * The integration slice's state, as the runtime state and `useIntegrationState()` hold it. The admin
+ * integration service is not part of it: the integration selectors own it, and
+ * `getAdminIntegrationService()` returns it.
+ */
 export interface IntegrationState {
-    readonly adminIntegrationService: AdminIntegrationService;
     readonly embeddedView: EmbeddedView;
 }

package/dist/react-sdk/application-runtime/loading/actions.d.ts

@@ -0,0 +1,45 @@
+import type { DomainApplicationType } from '#package/domain';
+import type { LoadingPhase, LoadingRuntimeState } from './types.js';
+interface Context {
+    readonly setLoading: (fn: (state: LoadingRuntimeState) => LoadingRuntimeState) => void;
+}
+/**
+ * Every action returns the slice unchanged when the value is already set, so the runtime publishes
+ * nothing and no subscriber recomputes.
+ */
+declare const createApplicationActions: (context: Context, applicationType: DomainApplicationType) => {
+    startPhase: (phase: LoadingPhase) => void;
+    endPhase: (id: string) => void;
+    reportError: () => void;
+    clearError: () => void;
+    expectPhase: (id: string) => void;
+    dropExpectation: (id: string) => void;
+    resetSlot: () => void;
+};
+/** One set of actions per application, as the domain context keys its own. */
+export declare const createLoadingActions: (context: Context) => {
+    configurator: {
+        startPhase: (phase: LoadingPhase) => void;
+        endPhase: (id: string) => void;
+        reportError: () => void;
+        clearError: () => void;
+        expectPhase: (id: string) => void;
+        dropExpectation: (id: string) => void;
+        resetSlot: () => void;
+    };
+    admin: {
+        startPhase: (phase: LoadingPhase) => void;
+        endPhase: (id: string) => void;
+        reportError: () => void;
+        clearError: () => void;
+        expectPhase: (id: string) => void;
+        dropExpectation: (id: string) => void;
+        resetSlot: () => void;
+    };
+};
+/**
+ * @internal Runtime plumbing for the SDK's own UI. A project reports a phase with
+ * `phx.frontend.useLoadingState()`.
+ */
+export type LoadingActions = ReturnType<typeof createApplicationActions>;
+export {};

package/dist/react-sdk/application-runtime/loading/actions.js

@@ -0,0 +1 @@
+import{initializeLoadingApplication as e}from"./initialize.js";let t=(e,t)=>e.has(t)?e:new Set([...e,t]),s=(s,r)=>{let a=e=>{s.setLoading(t=>{let s=t[r],a=e(s);return a===s?t:{...t,[r]:a}})},n=e=>{a(t=>t.hasError===e?t:{...t,hasError:e})};return{startPhase:e=>{a(s=>{let r=((e,t)=>{let s=e.findIndex(e=>e.id===t.id);if(-1===s)return[...e,t];let r=e[s];return void 0!==r&&r.id===t.id&&r.progress===t.progress&&r.label===t.label?e:e.map(e=>e.id===t.id?t:e)})(s.phases,e),a=t(s.seenPhaseIds,e.id);return r===s.phases&&a===s.seenPhaseIds?s:{...s,phases:r,seenPhaseIds:a}})},endPhase:e=>{a(t=>t.phases.some(t=>t.id===e)?{...t,phases:t.phases.filter(t=>t.id!==e)}:t)},reportError:()=>{n(!0)},clearError:()=>{n(!1)},expectPhase:e=>{a(s=>{let r=s.expectationCounts.get(e)??0,a=new Map(s.expectationCounts).set(e,r+1);return{...s,expectationCounts:a,expectedPhaseIds:t(s.expectedPhaseIds,e)}})},dropExpectation:e=>{a(t=>{let s=t.expectationCounts.get(e);if(void 0===s)return t;let r=new Map(t.expectationCounts);return s>1?(r.set(e,s-1),{...t,expectationCounts:r}):(r.delete(e),{...t,expectationCounts:r,expectedPhaseIds:((e,t)=>{if(!e.has(t))return e;let s=new Set(e);return s.delete(t),s})(t.expectedPhaseIds,e)})})},resetSlot:()=>{a(t=>0!==t.phases.length||t.hasError||0!==t.expectedPhaseIds.size||0!==t.seenPhaseIds.size?e():t)}}};export const createLoadingActions=e=>({configurator:s(e,"configurator"),admin:s(e,"admin")});

package/dist/react-sdk/application-runtime/loading/index.d.ts

@@ -0,0 +1,4 @@
+export * from './actions.js';
+export * from './initialize.js';
+export * from './selectors.js';
+export type * from './types.js';

package/dist/react-sdk/application-runtime/loading/index.js

@@ -0,0 +1 @@
+export*from"./actions.js";export*from"./initialize.js";export*from"./selectors.js";

package/dist/react-sdk/application-runtime/loading/initialize.d.ts

@@ -0,0 +1,3 @@
+import type { LoadingApplicationState, LoadingRuntimeState } from './types.js';
+export declare const initializeLoadingApplication: () => LoadingApplicationState;
+export declare const initializeLoading: () => LoadingRuntimeState;

package/dist/react-sdk/application-runtime/loading/initialize.js

@@ -0,0 +1 @@
+export const initializeLoadingApplication=()=>({phases:[],hasError:!1,expectedPhaseIds:new Set,expectationCounts:new Map,seenPhaseIds:new Set});export const initializeLoading=()=>({configurator:initializeLoadingApplication(),admin:initializeLoadingApplication()});

package/dist/react-sdk/application-runtime/loading/selectors.d.ts

@@ -0,0 +1,18 @@
+import type { DomainApplicationType } from '#package/domain';
+import type { LoadingRuntimeState, LoadingState } from './types.js';
+export interface LoadingSelectorState {
+    readonly loading: LoadingRuntimeState;
+}
+interface Context {
+    readonly getState: () => LoadingSelectorState;
+    readonly applicationType: DomainApplicationType;
+}
+/** The selectors of one application's loading state; the runtime creates one set per application. */
+export declare const createLoadingSelectors: (context: Context) => {
+    selectLoadingState: import("@salsita-ai/common/utils").Selector<LoadingSelectorState, LoadingState>;
+    getLoadingState: () => LoadingState;
+    /** Whether the phase `id` is expected and has not started since the last reset. */
+    getIsAwaitingPhase: (id: string) => boolean;
+};
+export type LoadingSelectors = ReturnType<typeof createLoadingSelectors>;
+export {};

package/dist/react-sdk/application-runtime/loading/selectors.js

@@ -0,0 +1 @@
+import{createSelector as e}from"@salsita-ai/common/utils";export const createLoadingSelectors=a=>{let{getState:s,applicationType:t}=a,i=e.withTypes(),o=i.leaf(e=>e.loading[t].phases),l=i.leaf(e=>e.loading[t].hasError),n=i.leaf(e=>e.loading[t].expectedPhaseIds),r=i.leaf(e=>e.loading[t].seenPhaseIds),g=i([o,l,n],(e,a,s)=>({isLoading:e.length>0,hasError:a,phases:e,expectedPhaseIds:s}));return{selectLoadingState:g,getLoadingState:()=>g(s()),getIsAwaitingPhase:e=>{let a=s();return n(a).has(e)&&!r(a).has(e)}}};