@nexia/sdk 0.5.0

package/dist/host.js

@@ -0,0 +1,803 @@
+import { createElement, useCallback, useEffect, useMemo, useRef, useState, } from 'react';
+import axios from 'axios';
+export { projectSignatureCapabilityCatalog, signatureCapabilityIdentity, } from './signature.js';
+let activeHost = null;
+/**
+ * Installs the host implementation behind the public App frontend contract.
+ * Core calls this once before installed App entries execute.
+ */
+export function configureNexiaAppFrontendHost(bindings) {
+    activeHost = bindings;
+}
+function host() {
+    if (activeHost === null) {
+        throw new Error('Nexia App frontend host is not configured. Core must configure the SDK before loading App entries.');
+    }
+    return activeHost;
+}
+const apiProxyTarget = axios.create();
+/** Axios-compatible host client carrying the active shell CSRF configuration. */
+export const api = new Proxy(apiProxyTarget, {
+    get(_target, property) {
+        const client = host().api;
+        const value = Reflect.get(client, property, client);
+        return typeof value === 'function' ? value.bind(client) : value;
+    },
+});
+function operationFailureMessage(operation) {
+    const validationMessage = operation.validation_errors
+        ? Object.values(operation.validation_errors)
+            .flat()
+            .find((value) => typeof value === 'string' && value.trim() !== '')
+        : undefined;
+    // `errors` contains stable translation keys for Core-owned displays. The
+    // SDK cannot translate those on an App's behalf, so only surface the
+    // server-localized validation detail here; an empty message lets the
+    // owning stage use its domain-specific fallback instead of exposing a key.
+    return validationMessage ?? '';
+}
+function waitForOperationPoll(signal) {
+    if (signal.aborted) {
+        return Promise.reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+    }
+    const delay = typeof document !== 'undefined'
+        && document.visibilityState === 'hidden'
+        ? 3000
+        : 1200;
+    return new Promise((resolve, reject) => {
+        const aborted = () => {
+            globalThis.clearTimeout(timer);
+            reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+        };
+        const timer = globalThis.setTimeout(() => {
+            signal.removeEventListener('abort', aborted);
+            resolve();
+        }, delay);
+        signal.addEventListener('abort', aborted, { once: true });
+    });
+}
+function backgroundOperationClientPath(statusUrl) {
+    const path = statusUrl.startsWith('/api/') ? statusUrl.slice(4) : statusUrl;
+    if (!path.startsWith('/') || path.startsWith('//')) {
+        throw new Error('Data migration operation status URL must be root-relative.');
+    }
+    return path;
+}
+/**
+ * Polls Core's standard background-operation endpoint and cancels outstanding
+ * waits when the owning surface unmounts.
+ */
+export function useDataMigrationBackgroundOperation() {
+    const activeControllers = useRef(new Set());
+    useEffect(() => () => {
+        for (const controller of activeControllers.current)
+            controller.abort();
+        activeControllers.current.clear();
+    }, []);
+    const cancelAll = useCallback(() => {
+        for (const controller of activeControllers.current)
+            controller.abort();
+        activeControllers.current.clear();
+    }, []);
+    const wait = useCallback(async (accepted, options = {}) => {
+        const ticket = typeof accepted === 'string' ? accepted : accepted.ticket;
+        const statusUrl = options.statusUrl
+            ?? (typeof accepted === 'string' ? undefined : accepted.status_url)
+            ?? `/resource-import/tickets/${encodeURIComponent(ticket)}`;
+        const controller = new AbortController();
+        const abortFromCaller = () => controller.abort(options.signal?.reason);
+        if (options.signal?.aborted)
+            abortFromCaller();
+        else
+            options.signal?.addEventListener('abort', abortFromCaller, { once: true });
+        activeControllers.current.add(controller);
+        try {
+            for (;;) {
+                const operation = (await api.get(backgroundOperationClientPath(statusUrl), { signal: controller.signal })).data;
+                options.onProgress?.(typeof operation.progress === 'number' ? operation.progress : 0, typeof operation.phase === 'string' ? operation.phase : null);
+                if (operation.status === 'completed') {
+                    if (operation.result === undefined) {
+                        throw new Error('Completed data migration operation has no result.');
+                    }
+                    return operation.result;
+                }
+                if (operation.status === 'failed' || operation.status === 'unknown') {
+                    throw new Error(operationFailureMessage(operation));
+                }
+                await waitForOperationPoll(controller.signal);
+            }
+        }
+        finally {
+            activeControllers.current.delete(controller);
+            options.signal?.removeEventListener('abort', abortFromCaller);
+        }
+    }, []);
+    return useMemo(() => ({ wait, cancelAll }), [cancelAll, wait]);
+}
+function render(component, props) {
+    return createElement(component, props);
+}
+export function AppRouteFrame(props) {
+    return render(host().components.AppRouteFrame, props);
+}
+export function InspectorAction(props) {
+    return render(host().components.InspectorAction, props);
+}
+export function InspectorResourceActions(props) {
+    return render(host().components.InspectorResourceActions, props);
+}
+export function ResourceLink(props) {
+    return render(host().components.ResourceLink, props);
+}
+export function NxAdaptiveSplit(props) {
+    return render(host().components.NxAdaptiveSplit, props);
+}
+export function NxActionButton(props) {
+    return render(host().components.NxActionButton, props);
+}
+export function NxAlert(props) {
+    return render(host().components.NxAlert, props);
+}
+export function NxButton(props) {
+    return render(host().components.NxButton, props);
+}
+export function NxLinkButton(props) {
+    return render(host().components.NxLinkButton, props);
+}
+export function NxIconButton(props) {
+    return render(host().components.NxIconButton, props);
+}
+export function NxIconLink(props) {
+    return render(host().components.NxIconLink, props);
+}
+/** Host-rendered action; Apps supply only a stable target. */
+export function FavoriteButton(props) {
+    return render(host().components.FavoriteButton, props);
+}
+export function NxCalendar(props) {
+    return render(host().components.NxCalendar, props);
+}
+export function NxBarChart(props) {
+    return render(host().components.NxBarChart, props);
+}
+export function NxLineChart(props) {
+    return render(host().components.NxLineChart, props);
+}
+export function NxInsightFilterBar(props) {
+    return render(host().components.NxInsightFilterBar, props);
+}
+export function NxInsightSurface(props) {
+    return render(host().components.NxInsightSurface, props);
+}
+export function NxOverviewBand(props) {
+    return render(host().components.NxOverviewBand, props);
+}
+export function NxDonutChart(props) {
+    return render(host().components.NxDonutChart, props);
+}
+export function NxGauge(props) {
+    return render(host().components.NxGauge, props);
+}
+export function NxHeatmap(props) {
+    return render(host().components.NxHeatmap, props);
+}
+export function NxResourceScheduler(props) {
+    return render(host().components.NxResourceScheduler, props);
+}
+export function NxResourceFormLegalEntityField(props) {
+    return render(host().components.NxResourceFormLegalEntityField, props);
+}
+export function NxResourceInformationForm(props) {
+    return createElement(host().components.NxResourceInformationForm, props);
+}
+export function NxResourceInformationView(props) {
+    return createElement(host().components.NxResourceInformationView, props);
+}
+export function NxSankey(props) {
+    return render(host().components.NxSankey, props);
+}
+export function NxDropdownMenu(props) {
+    return render(host().components.NxDropdownMenu, props);
+}
+export function NxCheckbox(props) {
+    return render(host().components.NxCheckbox, props);
+}
+export function NxRadio(props) {
+    return render(host().components.NxRadio, props);
+}
+export function NxRadioGroup(props) {
+    return render(host().components.NxRadioGroup, props);
+}
+export function NxRefreshControl(props) {
+    return render(host().components.NxRefreshControl, props);
+}
+export function NxColumnBrowser(props) {
+    return render(host().components.NxColumnBrowser, props);
+}
+export function NxColumnPicker(props) {
+    return render(host().components.NxColumnPicker, props);
+}
+export function NxCombobox(props) {
+    return createElement((host().components.NxCombobox), props);
+}
+export function NxOperatingUnitSelector(props) {
+    return render(host().components.NxOperatingUnitSelector, props);
+}
+export function NxOrganizationTargetSelector(props) {
+    return render(host().components.NxOrganizationTargetSelector, props);
+}
+export function NxDatePicker(props) {
+    return render(host().components.NxDatePicker, props);
+}
+export function NxDateRangePicker(props) {
+    return render(host().components.NxDateRangePicker, props);
+}
+export function NxDetailRow(props) {
+    return render(host().components.NxDetailRow, props);
+}
+export function NxEmptyView(props) {
+    return render(host().components.NxEmptyView, props);
+}
+export function NxFieldGroup(props) {
+    return render(host().components.NxFieldGroup, props);
+}
+export function NxFieldLegend(props) {
+    return render(host().components.NxFieldLegend, props);
+}
+export function NxFieldset(props) {
+    return render(host().components.NxFieldset, props);
+}
+export function NxFileDropzone(props) {
+    return render(host().components.NxFileDropzone, props);
+}
+export function NxFormField(props) {
+    return render(host().components.NxFormField, props);
+}
+export function NxFormSection(props) {
+    return render(host().components.NxFormSection, props);
+}
+export function NxHelpTooltip(props) {
+    return render(host().components.NxHelpTooltip, props);
+}
+export function NxLoadingBlock(props) {
+    return render(host().components.NxLoadingBlock, props);
+}
+export function NxModalDialog(props) {
+    return render(host().components.NxModalDialog, props);
+}
+export function SignatureInvitationChannelSelector(props) {
+    return render(host().components.SignatureInvitationChannelSelector, props);
+}
+export function SignatureAuthenticationMethodSelector(props) {
+    return render(host().components.SignatureAuthenticationMethodSelector, props);
+}
+/** Renders Core's request-local editor through the public App host boundary. */
+export function SignatureRequestPreparationEditor(props) {
+    return render(host().components.SignatureRequestPreparationEditor, props);
+}
+/** Renders the protected exact-PDF review through the public App host boundary. */
+export function SignatureRequestPreparationExactPreview(props) {
+    return render(host().components.SignatureRequestPreparationExactPreview, props);
+}
+/** Renders the placement-only request editor through the public App host boundary. */
+export function SignatureRequestPreparationPlacementEditor(props) {
+    return render(host().components.SignatureRequestPreparationPlacementEditor, props);
+}
+/** Renders Core's app-neutral single-request flow through the public host boundary. */
+export function SignatureSingleRequestDialog(props) {
+    return render(host().components.SignatureSingleRequestDialog, props);
+}
+export function NxCanonicalRoutePane(props) {
+    return render(host().components.NxCanonicalRoutePane, props);
+}
+export function NxOrgChart(props) {
+    return render(host().components.NxOrgChart, props);
+}
+export function NxResourceImportDialog(props) {
+    return render(host().components.NxResourceImportDialog, props);
+}
+export function NxResourceTransferActions(props) {
+    return render(host().components.NxResourceTransferActions, props);
+}
+export function NxDatasetImportWorkspace(props) {
+    return render(host().components.NxDatasetImportWorkspace, props);
+}
+export function NxDatasetExportWorkspace(props) {
+    return render(host().components.NxDatasetExportWorkspace, props);
+}
+export function NxMissingRequiredReferencesAlert(props) {
+    return render(host().components.NxMissingRequiredReferencesAlert, props);
+}
+export function NxPageFrame(props) {
+    return render(host().components.NxPageFrame, props);
+}
+export function NxResponsiveRegion(props) {
+    return render(host().components.NxResponsiveRegion, props);
+}
+export function NxPagination(props) {
+    return render(host().components.NxPagination, props);
+}
+export function NxSearchField(props) {
+    return render(host().components.NxSearchField, props);
+}
+export function NxSectionCard(props) {
+    return render(host().components.NxSectionCard, props);
+}
+export function NxSectionStack(props) {
+    return render(host().components.NxSectionStack, props);
+}
+export function NxSelect(props) {
+    return createElement((host().components.NxSelect), props);
+}
+export function NxStatCard(props) {
+    return render(host().components.NxStatCard, props);
+}
+export function NxStatusBadge(props) {
+    return render(host().components.NxStatusBadge, props);
+}
+export function NxTabNav(props) {
+    return render(host().components.NxTabNav, props);
+}
+export function NxTextArea(props) {
+    return render(host().components.NxTextArea, props);
+}
+export function NxTextInput(props) {
+    return render(host().components.NxTextInput, props);
+}
+export function NxTooltip(props) {
+    return render(host().components.NxTooltip, props);
+}
+export function OperatingUnitScopeField(props) {
+    return render(host().components.OperatingUnitScopeField, props);
+}
+export function OperatingUnitManagementSurface(props) {
+    return render(host().components.OperatingUnitManagementSurface, props);
+}
+export function ResourceInspectorPanel(props) {
+    return render(host().components.ResourceInspectorPanel, props);
+}
+export function ResourceInspectorStackHost(props) {
+    return render(host().components.ResourceInspectorStackHost, props);
+}
+export function ResourceInspectorStackProvider(props) {
+    return render(host().components.ResourceInspectorStackProvider, props);
+}
+export function ResourceInspectorState(props) {
+    return render(host().components.ResourceInspectorState, props);
+}
+export function ResourceBoard(props) {
+    return render(host().components.ResourceBoard, props);
+}
+export function ResourcePrimaryCell(props) {
+    return render(host().components.ResourcePrimaryCell, props);
+}
+export function ResourceListToolbarMoreMenu(props) {
+    return createElement((host().components.ResourceListToolbarMoreMenu), props);
+}
+export function ResourceRowActionsMenu(props) {
+    return render(host().components.ResourceRowActionsMenu, props);
+}
+export function ResourceStatusBadge(props) {
+    return render(host().components.ResourceStatusBadge, props);
+}
+export function ResourceSchedule(props) {
+    return render(host().components.ResourceSchedule, props);
+}
+export function ResourceTable(props) {
+    return createElement((host().components.ResourceTable), props);
+}
+export function ResourceTextCell(props) {
+    return render(host().components.ResourceTextCell, props);
+}
+export function WorkSection(props) {
+    return render(host().components.WorkSection, props);
+}
+export function WorkSurface(props) {
+    return render(host().components.WorkSurface, props);
+}
+export function useContextQuery() {
+    return host().hooks.useContextQuery();
+}
+export function useAffiliatedOperatingUnits(tenantId, legalEntityPublicId, permission, enabled = true) {
+    return host().hooks.useAffiliatedOperatingUnits(tenantId, legalEntityPublicId, permission, enabled);
+}
+export function useAgentToolDataInvalidation(enabled = true) {
+    host().hooks.useAgentToolDataInvalidation(enabled);
+}
+/**
+ * The freshness half of a widget's useQuery options, resolved by the host.
+ * Polling pauses while the surrounding Work Tab is parked, the host enforces
+ * its dashboard-wide minimum cadence, and slower refresh hints are honored.
+ * Realtime invalidation is a shell-owned accelerator, not the cadence contract.
+ */
+export function useAgentToolDataFreshness(options) {
+    return host().hooks.useAgentToolDataFreshness(options);
+}
+/**
+ * Stable identifier of the Work Tab that owns the surrounding App surface.
+ * Apps can use it to isolate session-only drafts that must survive a route-tree
+ * remount without leaking those drafts into durable browser storage.
+ */
+export function useActiveWorkTabId() {
+    return host().hooks.useActiveWorkTabId();
+}
+/**
+ * Whether the surrounding Work Tab is the visible pane rather than parked
+ * in the surface pool. Gate steady refetchInterval timers with this.
+ */
+export function useIsActiveWorkTabVisible() {
+    return host().hooks.useIsActiveWorkTabVisible();
+}
+export function useAssignableOperatingUnits(tenantId, legalEntityPublicId, permission, enabled = true) {
+    return host().hooks.useAssignableOperatingUnits(tenantId, legalEntityPublicId, permission, enabled);
+}
+export function useAttachments(tenantId, attachableType, attachablePublicId) {
+    return host().hooks.useAttachments(tenantId, attachableType, attachablePublicId);
+}
+/** Active-context Approval route-policy catalog for App-owned reference fields. */
+export function useApprovalRoutePoliciesQuery(tenantId, legalEntityPublicId, enabled = true) {
+    return host().hooks.useApprovalRoutePoliciesQuery(tenantId, legalEntityPublicId, enabled);
+}
+/** Shared approval lines always resolve from the stored record Legal Entity. */
+export function useApprovalSharedLinesQuery(tenantId, legalEntityPublicId, enabled = true) {
+    return host().hooks.useApprovalSharedLinesQuery(tenantId, legalEntityPublicId, enabled);
+}
+export function useDashboardWidgetAutoHeight(widgetId) {
+    return host().hooks.useDashboardWidgetAutoHeight(widgetId);
+}
+export function useDebouncedValue(value, delayMs = 300) {
+    return host().hooks.useDebouncedValue(value, delayMs);
+}
+export function useDeleteAttachment(tenantId, attachableType, attachablePublicId) {
+    return host().hooks.useDeleteAttachment(tenantId, attachableType, attachablePublicId);
+}
+export function useLegalEntitiesQuery(tenantId) {
+    return host().hooks.useLegalEntitiesQuery(tenantId);
+}
+/** Active tenant catalog for tenant-owned record applicability; never a Shell switcher source. */
+export function useLegalEntityApplicabilityQuery(tenantId, permission, enabled = true) {
+    return host().hooks.useLegalEntityApplicabilityQuery(tenantId, permission, enabled);
+}
+/** Exact permission-authorized Legal Entity and Operating Unit targets for an App surface. */
+export function useOrganizationTargetsQuery(tenantId, permission, query = {}, enabled = true) {
+    return host().hooks.useOrganizationTargetsQuery(tenantId, permission, query, enabled);
+}
+/** Page-owned read scope. Invalid or unavailable scope never supplies request parameters. */
+export function useOrganizationListScope(tenantId, permission, mode = 'legal-entity-list', enabled = true) {
+    return host().hooks.useOrganizationListScope(tenantId, permission, mode, enabled);
+}
+/** Legal Entity-bounded member options for App-owned assignment fields. */
+export function useLegalEntityMembersQuery(tenantId, legalEntityPublicId, params = {}, enabled = true) {
+    return host().hooks.useLegalEntityMembersQuery(tenantId, legalEntityPublicId, params, enabled);
+}
+export function useOperatingUnitScope(tenantId, legalEntityPublicId, permission, enabled = true) {
+    return host().hooks.useOperatingUnitScope(tenantId, legalEntityPublicId, permission, enabled);
+}
+export function useOperatingUnitSelection(tenantId, legalEntityPublicId, permission, enabled = true) {
+    return host().hooks.useOperatingUnitSelection(tenantId, legalEntityPublicId, permission, enabled);
+}
+export function useOperatingUnitsQuery(tenantId, legalEntityPublicId, scope = 'memberships', permission, enabled = true) {
+    return host().hooks.useOperatingUnitsQuery(tenantId, legalEntityPublicId, scope, permission, enabled);
+}
+export function useParties(tenantId, params, enabled = true) {
+    return host().hooks.useParties(tenantId, params, enabled);
+}
+export function useUploadAttachment(tenantId, attachableType, attachablePublicId, options) {
+    return host().hooks.useUploadAttachment(tenantId, attachableType, attachablePublicId, options);
+}
+/**
+ * Starts a host-issued upload intent. The host may proxy the bytes or send
+ * them directly to object storage; App code never selects the transport.
+ */
+export function useUploadFile() {
+    return host().hooks.useUploadFile();
+}
+/** Lists metadata for assets that the host can safely apply to a bound resource. */
+export function useTrustedAssetsQuery(tenantId, legalEntityPublicId, params, enabled = true) {
+    return host().hooks.useTrustedAssetsQuery(tenantId, legalEntityPublicId, params, enabled);
+}
+/** Uploads a standalone Media resource through the configured Nexia host. */
+export function useUploadMedia(tenantId) {
+    return host().hooks.useUploadMedia(tenantId);
+}
+/** Sends a host-owned login invitation without exposing Core internals to an App. */
+export async function sendUserInvitation(payload) {
+    const { data } = await host().api.post('/users/invitations', payload);
+    return data;
+}
+export function usePermissionsQuery(tenantId, legalEntityPublicId, operatingUnitPublicId = null, enabled = true) {
+    return host().hooks.usePermissionsQuery(tenantId, legalEntityPublicId, operatingUnitPublicId, enabled);
+}
+/** Refreshes App-owned state when its committed resource projection changes. */
+export function useResourceProjectionChange(subscription) {
+    host().hooks.useResourceProjectionChange(subscription);
+}
+export function useResourceListParams(options = {}) {
+    return host().hooks.useResourceListParams(options);
+}
+/** URL-backed date range for an Insights destination. */
+export function useInsightFilterState(options = {}) {
+    return host().hooks.useInsightFilterState(options);
+}
+export function useDateTimeFormatter(options) {
+    return host().hooks.useDateTimeFormatter(options);
+}
+export function useMessage() {
+    return host().hooks.useMessage();
+}
+let nextFeedbackActionId = 1;
+/**
+ * Adds standard pending, duplicate-submission, and result feedback behavior to
+ * an App operation without exposing the Shell message store.
+ *
+ * @example
+ * const save = useFeedbackAction(saveEmployee, {
+ *     success: 'Saved.',
+ *     error: 'Could not save.',
+ *     dedupeKey: 'employees:save',
+ *     undo: {
+ *         label: 'Undo',
+ *         operation: (saved, [input]) => restoreEmployee(saved.id, input),
+ *         success: 'Save undone.',
+ *         error: 'Could not undo the save.',
+ *     },
+ * });
+ *
+ * <NxActionButton
+ *     kind="save"
+ *     label="Save"
+ *     loading={save.pending}
+ *     onClick={() => void save.run(values)}
+ * />
+ */
+export function useFeedbackAction(operation, options) {
+    const message = useMessage();
+    const [generatedId] = useState(() => `feedback-${nextFeedbackActionId++}`);
+    const [pending, setPending] = useState(false);
+    const mounted = useRef(false);
+    const inFlight = useRef(null);
+    const messageRef = useRef(message);
+    const operationRef = useRef(operation);
+    const optionsRef = useRef(options);
+    messageRef.current = message;
+    operationRef.current = operation;
+    optionsRef.current = options;
+    useEffect(() => {
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
+    const runOrThrow = useCallback((...arguments_) => {
+        if (inFlight.current)
+            return inFlight.current;
+        if (mounted.current)
+            setPending(true);
+        const activeOperation = operationRef.current;
+        const activeOptions = optionsRef.current;
+        const dedupeKey = activeOptions.dedupeKey ?? `operation:${generatedId}`;
+        const operationPromise = Promise.resolve()
+            .then(() => activeOperation(...arguments_))
+            .then((result) => {
+            const undoArguments = Object.assign([], arguments_);
+            try {
+                showFeedbackToast(messageRef.current, 'success', activeOptions.success, result, arguments_, dedupeKey, () => createFeedbackUndoAction(messageRef.current, activeOptions.undo, result, undoArguments, dedupeKey));
+            }
+            catch {
+                // Presentation must not turn a completed operation into
+                // a rejected workflow. The successful result remains
+                // authoritative even if an App supplied faulty copy.
+            }
+            return result;
+        }, (error) => {
+            try {
+                showFeedbackToast(messageRef.current, 'error', activeOptions.error, error, arguments_, dedupeKey);
+            }
+            catch {
+                // Feedback copy is presentation code. A faulty resolver
+                // must not replace the operation error promised by
+                // runOrThrow(); the caller still receives the original
+                // rejection and can recover at its own boundary.
+            }
+            throw error;
+        })
+            .finally(() => {
+            if (inFlight.current !== operationPromise)
+                return;
+            inFlight.current = null;
+            if (mounted.current)
+                setPending(false);
+        });
+        inFlight.current = operationPromise;
+        return operationPromise;
+    }, [generatedId]);
+    const run = useCallback((...arguments_) => runOrThrow(...arguments_).catch(() => undefined), [runOrThrow]);
+    return { run, runOrThrow, pending };
+}
+function showFeedbackToast(message, variant, resolver, value, arguments_, dedupeKey, fallbackAction) {
+    const resolved = typeof resolver === 'function'
+        ? resolver(value, arguments_)
+        : resolver;
+    const presentation = typeof resolved === 'string'
+        ? { title: resolved }
+        : resolved;
+    const { title, ...toastOptions } = presentation;
+    let action = toastOptions.action;
+    if (!action && fallbackAction) {
+        try {
+            action = fallbackAction();
+        }
+        catch {
+            // Invalid optional action configuration must not suppress the
+            // successful operation's ordinary feedback.
+        }
+    }
+    message.toast[variant](title, {
+        ...toastOptions,
+        ...(action ? { action } : {}),
+        dedupeKey,
+        source: 'operation',
+    });
+}
+function createFeedbackUndoAction(message, undo, result, arguments_, dedupeKey) {
+    if (!undo)
+        return undefined;
+    const { label, operation, success, error } = undo;
+    if (typeof label !== 'string' || label.trim() === '' || typeof operation !== 'function') {
+        return undefined;
+    }
+    const capturedArguments = arguments_;
+    let invoked = false;
+    return {
+        label,
+        onAction: () => {
+            if (invoked)
+                return;
+            invoked = true;
+            void Promise.resolve()
+                .then(() => operation(result, capturedArguments))
+                .then((undoResult) => {
+                try {
+                    showFeedbackToast(message, 'success', success, undoResult, capturedArguments, `${dedupeKey}:undo`);
+                }
+                catch {
+                    // Undo feedback is presentation-only. A broken
+                    // resolver cannot rewrite the completed inverse.
+                }
+            }, (undoError) => {
+                try {
+                    showFeedbackToast(message, 'error', error, undoError, capturedArguments, `${dedupeKey}:undo`);
+                }
+                catch {
+                    // The inverse rejection is already contained by the
+                    // action boundary; faulty feedback stays isolated.
+                }
+            });
+        },
+    };
+}
+export function useRegisterListLocateAction(options) {
+    host().hooks.useRegisterListLocateAction(options);
+}
+export function useOpenResourceWorkTab(defaultIcon = 'document') {
+    return host().hooks.useOpenResourceWorkTab(defaultIcon);
+}
+export function useRegisterResourceCreateReceiver(registration) {
+    host().hooks.useRegisterResourceCreateReceiver(registration);
+}
+export function useResourceCreateCompletion() {
+    return host().hooks.useResourceCreateCompletion();
+}
+export function useMarkTabDirty(dirty) {
+    host().hooks.useMarkTabDirty(dirty);
+}
+export function useRegisterTabActions(actions) {
+    host().hooks.useRegisterTabActions(actions);
+}
+export function useWorkTabLabel(label) {
+    host().hooks.useWorkTabLabel(label);
+}
+export function useWorkSurfaceLabels(input) {
+    return host().hooks.useWorkSurfaceLabels(input);
+}
+export function autoRegisterPackageSurfaces(options) {
+    host().runtime.autoRegisterPackageSurfaces(options);
+}
+/**
+ * Declares the filesystem-owned inspector registration set for an App entry.
+ *
+ * Vite evaluates an eager `import.meta.glob` before passing the modules here;
+ * each generated registration module then registers its lazy inspector loader.
+ * Keeping the convention in the SDK means an App never needs to maintain a
+ * growing list of side-effect imports in its entry point.
+ */
+export function autoRegisterPackageResourceInspectors(modules) {
+    const pattern = /^\.\/resources\/[^/]+\/inspector\/register-[^/]+-inspector\.ts$/;
+    for (const path of Object.keys(modules)) {
+        if (!pattern.test(path)) {
+            throw new Error(`Invalid package inspector registration path [${path}].`);
+        }
+    }
+}
+export function firstFieldError(errors, field) {
+    return host().runtime.firstFieldError(errors, field);
+}
+export function withoutFieldError(errors, field) {
+    return host().runtime.withoutFieldError(errors, field);
+}
+export function parseMutationFormError(input) {
+    return host().runtime.parseMutationFormError(input);
+}
+export function keepPreviousResourceListData(queryScope) {
+    return host().runtime.keepPreviousResourceListData(queryScope);
+}
+export function readResourceListParams(searchParams, options = {}) {
+    return host().runtime.readResourceListParams(searchParams, options);
+}
+export function registerAgentComponent(name, renderer) {
+    host().runtime.registerAgentComponent(name, renderer);
+}
+/** Register an App-owned Agent renderer without placing it in the App entry chunk. */
+export function registerLazyAgentComponent(name, loader) {
+    host().runtime.registerLazyAgentComponent(name, loader);
+}
+export function can(permissions, permission) {
+    if (permissions.includes(permission))
+        return true;
+    return permissions.some((pattern) => {
+        if (!pattern.endsWith('.*'))
+            return false;
+        const prefix = pattern.slice(0, -1);
+        return permission.startsWith(prefix);
+    });
+}
+export function serializeResourceTableSort(sort) {
+    if (!sort)
+        return undefined;
+    return sort.dir === 'desc' ? `-${sort.key}` : sort.key;
+}
+function registerApprovalBusinessForm(registrationOrKey, legacyLoader) {
+    if (typeof registrationOrKey === 'string') {
+        host().registries.approvalComposerBusinessFormRegistry.register(registrationOrKey, legacyLoader);
+        return;
+    }
+    host().registries.approvalComposerBusinessFormRegistry.register(registrationOrKey);
+}
+export const approvalComposerBusinessFormRegistry = {
+    register: registerApprovalBusinessForm,
+};
+export const dataMigrationRegistry = {
+    registerProvider(registration) {
+        host().registries.dataMigrationRegistry.registerProvider(registration);
+    },
+    registerTarget(registration) {
+        host().registries.dataMigrationRegistry.registerTarget(registration);
+    },
+    registerStage(registration) {
+        host().registries.dataMigrationRegistry.registerStage(registration);
+    },
+};
+export const processUserTaskFormRegistry = {
+    register(registration) {
+        host().registries.processUserTaskFormRegistry.register(registration);
+    },
+};
+/** Stable Resource-key resolver for cross-App contextual create flows. */
+export const resourceCreateDestinationRegistry = {
+    register(registration) {
+        host().registries.resourceCreateDestinationRegistry.register(registration);
+    },
+    resolve(resourceKey, query) {
+        return host().registries.resourceCreateDestinationRegistry.resolve(resourceKey, query);
+    },
+};
+function registerResourceInspectorAdapter(type, loader) {
+    host().registries.resourceInspectorAdapterRegistry.register(type, loader);
+}
+export const resourceInspectorAdapterRegistry = {
+    register: registerResourceInspectorAdapter,
+};
+/** Shared spreadsheet editor; the caller owns document persistence. */
+export function NxSpreadsheetEditor(props) {
+    return render(host().components.NxSpreadsheetEditor, props);
+}