@finesoft/front 0.5.0 → 0.5.2

package/dist/vue-DGmzuKho.d.mts

@@ -0,0 +1,32 @@
+import { f as AppSnapshot, g as WebAppView, h as ViewProps } from "./session-DnB4ZC3x.mjs";
+import { Component, PropType } from "vue";
+declare namespace vue_d_exports {
+  export { NativeView, NativeViews, Outlet, ViewProps, WebAppView, useSnapshot };
+}
+type NativeView = Component;
+type NativeViews = Readonly<Record<string, NativeView>>;
+declare function useSnapshot(app: WebAppView): import("vue").ShallowRef<AppSnapshot, AppSnapshot>;
+declare const Outlet: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  app: {
+    type: PropType<WebAppView>;
+    required: true;
+  };
+  views: {
+    type: PropType<NativeViews>;
+    required: true;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  app: {
+    type: PropType<WebAppView>;
+    required: true;
+  };
+  views: {
+    type: PropType<NativeViews>;
+    required: true;
+  };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { vue_d_exports as a, useSnapshot as i, NativeViews as n, Outlet as r, NativeView as t };
+//# sourceMappingURL=vue-DGmzuKho.d.mts.map

package/dist/vue.d.mts

@@ -0,0 +1,3 @@
+import { g as WebAppView, h as ViewProps } from "./session-DnB4ZC3x.mjs";
+import { i as useSnapshot, n as NativeViews, r as Outlet, t as NativeView } from "./vue-DGmzuKho.mjs";
+export { NativeView, NativeViews, Outlet, type ViewProps, type WebAppView, useSnapshot };

package/dist/vue.mjs

@@ -0,0 +1,56 @@
+import { defineComponent, h, nextTick, onMounted, onUnmounted, onUpdated, shallowRef } from "vue";
+//#region src/vue.ts
+function useSnapshot(app) {
+	const snapshot = shallowRef(app.getSnapshot());
+	const unsubscribe = app.subscribe(() => {
+		snapshot.value = app.getSnapshot();
+	});
+	onUnmounted(unsubscribe);
+	return snapshot;
+}
+const Outlet = defineComponent({
+	name: "FinesoftOutlet",
+	props: {
+		app: {
+			type: Object,
+			required: true
+		},
+		views: {
+			type: Object,
+			required: true
+		}
+	},
+	setup(props) {
+		const snapshot = useSnapshot(props.app);
+		let renderedRevision = snapshot.value.revision;
+		const commit = () => {
+			const revision = renderedRevision;
+			nextTick(() => props.app.commit(revision));
+		};
+		onMounted(commit);
+		onUpdated(commit);
+		return () => {
+			renderedRevision = snapshot.value.revision;
+			return h("main", { "data-fs-outlet": "" }, snapshot.value.entries.map((entry) => {
+				const View = props.views[entry.page.pageType] ?? props.views["*"];
+				if (!View) throw Error("Missing view: " + entry.page.pageType);
+				return h("div", {
+					key: entry.entryId,
+					hidden: !entry.visible,
+					"data-fs-entry": entry.entryId,
+					"data-fs-key": entry.entryId,
+					"data-fs-intent": entry.intent
+				}, [h(View, {
+					key: entry.entryId + ":" + entry.page.pageType,
+					page: entry.page,
+					app: props.app,
+					entry
+				})]);
+			}));
+		};
+	}
+});
+//#endregion
+export { Outlet, useSnapshot };
+
+//# sourceMappingURL=vue.mjs.map

package/dist/web.d.mts

@@ -0,0 +1,6 @@
+import { A as makeSchema, C as ImpressionEntry, D as StandardIssue, E as ParamSchema, F as Token, I as createToken, M as Provider, N as ProviderContext, O as StandardResult, P as provide, S as EventRecorder, T as InferOutput, _ as OperationPolicy, a as compilePath, b as RuntimeOptions, c as ExecutionContext, d as ExecutionHandle, f as Implementation, g as OperationHandler, h as Operation, i as PathParams, j as Container, k as StandardSchemaV1, l as ExecutionError, m as ModuleDefinition, n as PathDescriptor, o as AnyOperation, p as Invocation, r as PathParameterDescriptor, s as AppDefinition, t as CompiledPath, u as ExecutionErrorCode, v as QueryCache, w as MetricsFieldsProvider, x as executionErrorFromHttp, y as RuntimeHandle } from "./path-CXT6xGPO.mjs";
+import { $ as createActiveLeafCodec, $n as list, $t as MiddlewareResult, A as SessionStore, An as PlatformInfo, At as isCompoundAction, B as ControllerContext, Bn as ConsoleLoggerFactory, Bt as NavigationPath, C as SessionFailure, Cn as Storage, Ct as ACTION_KINDS, D as SessionSlice, Dn as LocaleInfo, Dt as ExternalUrlAction, E as SessionRestoreResult, En as LocaleAttributes, Et as CompoundAction, F as WebRuntime, Fn as ReportCallback, Ft as LeafNode, G as controllerContext, Gn as InferParams, Gt as SplitColumn, H as SERVER_CONTROLLER, Hn as Logger, Ht as NavigationSnapshot, I as WebRuntimeOptions, In as ReportingLogger, It as NAVIGATION_NODE_KINDS, J as resolveConfiguredMessages, Jn as QuerySchemaMap, Jt as StackNode, K as MessagesLoader, Kn as InferQuery, Kt as SplitNode, L as createWebRuntime, Ln as ReportingLoggerFactory, Lt as NavigationError, M as SessionWriteResult, Mn as BaseController, Mt as isFlowAction, N as StorageUnavailableError, Nn as ControllerFailure, Nt as makeExternalUrlAction, O as SessionSnapshot, On as TextDirection, Ot as FlowAction, P as WebConfiguration, Pn as ControllerInput, Pt as makeFlowAction, Q as NavigationRouterLike, Qn as isMultiValueSchema, Qt as DenyResult, R as PageControllerDefinition, Rn as ReportingLoggerOptions, Rt as NavigationNode, S as SessionErrorContext, Sn as FeatureFlagsProvider, St as ActionHandler, T as SessionNavigation, Tn as resolveMessages, Tt as ActionInvocation, U as SERVER_REQUEST, Un as LoggerFactory, Ut as ResolvedDestination, V as PageControllerInput, Vn as LogFilter, Vt as NavigationPathStep, W as ServerRequestState, Wn as ExtractParamNames, Wt as SPLIT_VISIBILITIES, X as FullStateCodecOptions, Xn as ListOptions, Xt as AfterLoadGuard, Y as DEFAULT_NAV_PARAM, Yn as StripOptional, Yt as TabsNode, Z as NavigationCodec, Zn as MultiValueSchema, Zt as BeforeLoadGuard, _ as AsyncStorage, _n as RouteInput, _t as PrefetchedIntents, a as NavigationCommitContext, an as deny, at as SerializedSplit, b as SESSION_DEFAULT_VERSION, bn as DEP_KEYS, bt as Router, c as NavigationTransactionContext, cn as rewrite, ct as SerializedTabs, d as createWebSession, dn as FINESOFT_PUBLIC, dt as serializeNavigationStable, en as NavigationContext, er as Intent, et as createFullStateCodec, f as AppSnapshot, fn as PublicProjection, ft as PageRoute, g as WebAppView, gn as markPublic, gt as PrefetchedIntent, h as ViewProps, hn as isPublicMarked, ht as route, i as BeforeNavigateResult, in as RewriteResult, it as SerializedNavigation, j as SessionStoreOptions, jn as detectPlatform, jt as isExternalUrlAction, k as SessionStateProvider, kn as Translator, kt as TreeAction, l as WebSession, ln as BASE_PAGE_FIELDS, lt as deserializeNavigation, m as ViewEntry, mn as getPublicFields, mt as RouteDefinition, n as BeforeCommitResult, nn as PostLoadContext, nt as encodeNavigationTreeParam, o as NavigationCommitError, on as next, ot as SerializedSplitColumn, p as NavigationSummary, pn as PublicValueCodec, pt as RenderMode, q as MessagesLoaderContext, qn as ParamsFor, qt as SplitVisibility, r as BeforeNavigatePolicy, rn as RedirectResult, rt as SerializedLeaf, s as NavigationContextInput, sn as redirect, st as SerializedStack, t as BeforeCommitPolicy, tn as NextResult, tt as decodeNavigationTreeParam, u as WebSessionOptions, un as BasePage, ut as serializeNavigation, v as NavigationScopedState, vn as RouteIntent, vt as RouteAddOptions, w as SessionLoadResult, wn as TranslationMessages, wt as Action, x as SessionError, xn as FeatureFlags, xt as ActionDispatcher, y as SESSION_DEFAULT_KEY, yn as RouteParams, yt as RouteMatch, z as WebAppDefinition, zn as ConsoleLogger, zt as NavigationNodeKind } from "./session-DnB4ZC3x.mjs";
+import { $ as SimpleTranslatorOptions, $t as uuid, A as setVisibility, At as fetchWithRedirects, B as split, Bt as HttpError, C as popTo, Ct as isSome, D as resolveActivePath, Dt as mapEach, E as replaceTop, Et as Mapper, F as isLeafNode, Ft as HttpClientConfig, G as safeErrorPage, Gt as withDefault, H as tabs, Ht as CompositeLogger, I as isSplitNode, It as HttpRequestOptions, J as defineModule, Jt as bool, K as createRuntime, Kt as NumOptions, L as isStackNode, Lt as RequestInterceptor, M as resourceKey, Mt as classifyHost, N as SplitColumnInit, Nt as classifyUrl, O as selectColumn, Ot as pipe, P as TabsInit, Pt as HttpClient, Q as SimpleTranslator, Qt as str, R as isTabsNode, Rt as ResponseInterceptor, S as pop, St as isNone, T as push, Tt as AsyncMapper, U as RouteInputFor, Ut as CompositeLoggerFactory, V as stack, Vt as stableStringify, W as SafeErrorPageOptions, Wt as optional, X as implementController, Xt as num, Y as defineOperation, Yt as int, Z as implementOperation, Zt as oneOf, _ as collectAllLeaves, _t as removeHost, a as LoadPageOptions, at as PluralCategory, b as findNode, bt as None, c as defineWebApp, ct as interpolate, d as runBeforeLoadGuards, dt as VoidEventRecorder, et as getLocaleAttributes, f as createSessionStore, ft as ConsoleEventRecorder, g as encodeSnapshot, gt as getBaseUrl, h as decodeSnapshot, ht as buildUrl, i as resolveInitialNavigation, it as resolveLocaleFromUrl, j as visibleSplitColumns, jt as HostCheckResult, k as selectTab, kt as pipeAsync, l as getWebPlan, lt as resolvePluralKey, m as createNavigationScopedState, mt as generateUuid, n as PageReference, nt as isRtl, o as PageLoadResult, ot as PluralRuleProvider, p as collectLeafKeys, pt as CompositeEventRecorder, q as defineApp, qt as StrOptions, r as definePage, rt as makeLocaleInfo, s as loadPage, st as englishPlural, t as parseCookieString, tt as getTextDirection, u as runAfterLoadGuards, ut as WithFieldsRecorder, v as collectVisibleDestinations, vt as removeQueryParams, w as popToRoot, wt as LruMap, x as mapNavigationLeaves, xt as Optional, y as findNearestStack, yt as removeScheme, z as leaf, zt as HostGuardError } from "./cookies-Bpf9VayB.mjs";
+import { a as enforceHostGuard, i as TargetGuardOptions, n as secureFetch, r as DnsLookup, t as SecureFetchOptions } from "./secure-fetch-Xlht2jd7.mjs";
+import { a as WebHydration, c as decodeWireEnvelope, i as FRAMEWORK_PROTOCOL_VERSION, l as getFrameworkBuildId, n as ServerControllerProxy, o as WireDecodeResult, r as ServerControllerRequest, s as WireEnvelope, t as SERVER_CONTROLLER_PATH } from "./server-controller-proxy-BkVuVWVD.mjs";
+export { ACTION_KINDS, type Action, ActionDispatcher, type ActionHandler, type ActionInvocation, type AfterLoadGuard, AnyOperation, AppDefinition, AppSnapshot, type AsyncMapper, type AsyncStorage, BASE_PAGE_FIELDS, BaseController, type BasePage, type BeforeCommitPolicy, type BeforeCommitResult, type BeforeLoadGuard, type BeforeNavigatePolicy, type BeforeNavigateResult, type CompiledPath, CompositeEventRecorder, CompositeLogger, CompositeLoggerFactory, type CompoundAction, ConsoleEventRecorder, ConsoleLogger, ConsoleLoggerFactory, Container, ControllerContext, type ControllerFailure, type ControllerInput, DEFAULT_NAV_PARAM, DEP_KEYS, type DenyResult, type DnsLookup, type EventRecorder, ExecutionContext, ExecutionError, ExecutionErrorCode, ExecutionHandle, type ExternalUrlAction, type ExtractParamNames, FINESOFT_PUBLIC, FRAMEWORK_PROTOCOL_VERSION, type FeatureFlags, type FeatureFlagsProvider, type FlowAction, type FullStateCodecOptions, type HostCheckResult, HostGuardError, HttpClient, type HttpClientConfig, HttpError, type HttpRequestOptions, Implementation, type ImpressionEntry, type InferOutput, type InferParams, type InferQuery, type Intent, Invocation, type LeafNode, type ListOptions, type LoadPageOptions, type LocaleAttributes, type LocaleInfo, type LogFilter, type Logger, type LoggerFactory, LruMap, type Mapper, type MessagesLoader, type MessagesLoaderContext, type MetricsFieldsProvider, type MiddlewareResult, ModuleDefinition, type MultiValueSchema, NAVIGATION_NODE_KINDS, type NavigationCodec, type NavigationCommitContext, NavigationCommitError, type NavigationContext, type NavigationContextInput, NavigationError, type NavigationNode, type NavigationNodeKind, type NavigationPath, type NavigationPathStep, type NavigationRouterLike, type NavigationScopedState, type NavigationSnapshot, NavigationSummary, type NavigationTransactionContext, type NextResult, type None, type NumOptions, Operation, OperationHandler, OperationPolicy, type Optional, type PageControllerDefinition, PageControllerInput, type PageLoadResult, type PageReference, type PageRoute, type ParamSchema, type ParamsFor, type PathDescriptor, type PathParameterDescriptor, type PathParams, type PlatformInfo, type PluralCategory, type PluralRuleProvider, type PostLoadContext, type PrefetchedIntent, PrefetchedIntents, type Provider, type ProviderContext, type PublicProjection, type PublicValueCodec, QueryCache, type QuerySchemaMap, type RedirectResult, type RenderMode, type ReportCallback, ReportingLogger, ReportingLoggerFactory, type ReportingLoggerOptions, type RequestInterceptor, type ResolvedDestination, type ResponseInterceptor, type RewriteResult, type RouteAddOptions, type RouteDefinition, type RouteInput, type RouteInputFor, type RouteIntent, type RouteMatch, type RouteParams, Router, RuntimeHandle, RuntimeOptions, SERVER_CONTROLLER, SERVER_CONTROLLER_PATH, SERVER_REQUEST, SESSION_DEFAULT_KEY, SESSION_DEFAULT_VERSION, SPLIT_VISIBILITIES, type SafeErrorPageOptions, type SecureFetchOptions, type SerializedLeaf, type SerializedNavigation, type SerializedSplit, type SerializedSplitColumn, type SerializedStack, type SerializedTabs, ServerControllerProxy, type ServerControllerRequest, ServerRequestState, SessionError, type SessionErrorContext, type SessionFailure, type SessionLoadResult, type SessionNavigation, type SessionRestoreResult, type SessionSlice, type SessionSnapshot, type SessionStateProvider, type SessionStore, type SessionStoreOptions, type SessionWriteResult, SimpleTranslator, type SimpleTranslatorOptions, type SplitColumn, type SplitColumnInit, type SplitNode, type SplitVisibility, type StackNode, type StandardIssue, type StandardResult, type StandardSchemaV1, type Storage, StorageUnavailableError, type StrOptions, type StripOptional, type TabsInit, type TabsNode, type TargetGuardOptions, type TextDirection, type Token, type TranslationMessages, type Translator, type TreeAction, ViewEntry, ViewProps, VoidEventRecorder, type WebAppDefinition, WebAppView, type WebConfiguration, type WebHydration, type WebRuntime, type WebRuntimeOptions, type WebSession, type WebSessionOptions, type WireDecodeResult, type WireEnvelope, WithFieldsRecorder, bool, buildUrl, classifyHost, classifyUrl, collectAllLeaves, collectLeafKeys, collectVisibleDestinations, compilePath, controllerContext, createActiveLeafCodec, createFullStateCodec, createNavigationScopedState, createRuntime, createSessionStore, createToken, createWebRuntime, createWebSession, decodeNavigationTreeParam, decodeSnapshot, decodeWireEnvelope, defineApp, defineModule, defineOperation, definePage, defineWebApp, deny, deserializeNavigation, detectPlatform, encodeNavigationTreeParam, encodeSnapshot, enforceHostGuard, englishPlural, executionErrorFromHttp, fetchWithRedirects, findNearestStack, findNode, generateUuid, getBaseUrl, getFrameworkBuildId, getLocaleAttributes, getPublicFields, getTextDirection, getWebPlan, implementController, implementOperation, int, interpolate, isCompoundAction, isExternalUrlAction, isFlowAction, isLeafNode, isMultiValueSchema, isNone, isPublicMarked, isRtl, isSome, isSplitNode, isStackNode, isTabsNode, leaf, list, loadPage, makeExternalUrlAction, makeFlowAction, makeLocaleInfo, makeSchema, mapEach, mapNavigationLeaves, markPublic, next, num, oneOf, optional, parseCookieString, pipe, pipeAsync, pop, popTo, popToRoot, provide, push, redirect, removeHost, removeQueryParams, removeScheme, replaceTop, resolveActivePath, resolveConfiguredMessages, resolveInitialNavigation, resolveLocaleFromUrl, resolveMessages, resolvePluralKey, resourceKey, rewrite, route, runAfterLoadGuards, runBeforeLoadGuards, safeErrorPage, secureFetch, selectColumn, selectTab, serializeNavigation, serializeNavigationStable, setVisibility, split, stableStringify, stack, str, tabs, uuid, visibleSplitColumns, withDefault };

package/dist/web.mjs

@@ -0,0 +1,8 @@
+import { $ as isLeafNode, A as createActiveLeafCodec, At as getTextDirection, B as findNode, Bt as fetchWithRedirects, C as runBeforeLoadGuards, Ct as defineModule, D as SERVER_REQUEST, Dt as SimpleTranslator, E as SERVER_CONTROLLER, Et as implementOperation, F as serializeNavigation, Ft as interpolate, G as push, Gt as ConsoleLogger, H as pop, Ht as stableStringify, I as serializeNavigationStable, It as resolvePluralKey, J as selectColumn, Jt as CompositeLoggerFactory, K as replaceTop, Kt as ConsoleLoggerFactory, L as collectAllLeaves, Lt as generateUuid, M as decodeNavigationTreeParam, Mt as makeLocaleInfo, N as encodeNavigationTreeParam, Nt as resolveLocaleFromUrl, O as controllerContext, Ot as resolveMessages, P as deserializeNavigation, Pt as englishPlural, Q as resourceKey, R as collectVisibleDestinations, Rt as detectPlatform, S as runAfterLoadGuards, St as defineApp, T as getWebPlan, Tt as implementController, U as popTo, Ut as ReportingLogger, V as mapNavigationLeaves, Vt as enforceHostGuard, W as popToRoot, Wt as ReportingLoggerFactory, X as setVisibility, Xt as list, Y as selectTab, Yt as isMultiValueSchema, Z as visibleSplitColumns, Zt as Container, _ as SERVER_CONTROLLER_PATH, _t as isFlowAction, a as createSessionStore, at as stack, b as decodeWireEnvelope, bt as provide, c as decodeSnapshot, ct as NavigationError, d as createWebSession, dt as PrefetchedIntents, et as isSplitNode, f as SESSION_DEFAULT_KEY, ft as Router, g as loadPage, gt as isExternalUrlAction, h as StorageUnavailableError, ht as isCompoundAction, i as createWebRuntime, it as split, j as createFullStateCodec, jt as isRtl, k as DEFAULT_NAV_PARAM, kt as getLocaleAttributes, l as encodeSnapshot, lt as SPLIT_VISIBILITIES, m as SessionError, mt as ACTION_KINDS, n as definePage, nt as isTabsNode, o as collectLeafKeys, ot as tabs, p as SESSION_DEFAULT_VERSION, pt as ActionDispatcher, q as resolveActivePath, qt as CompositeLogger, r as resolveInitialNavigation, rt as leaf, s as createNavigationScopedState, st as NAVIGATION_NODE_KINDS, t as parseCookieString, tt as isStackNode, u as NavigationCommitError, ut as route, v as ServerControllerProxy, vt as makeExternalUrlAction, w as defineWebApp, wt as defineOperation, x as getFrameworkBuildId, xt as createRuntime, y as FRAMEWORK_PROTOCOL_VERSION, yt as makeFlowAction, z as findNearestStack, zt as secureFetch } from "./src-qwx7Vw8g.mjs";
+import { C as bool, D as str, E as oneOf, O as uuid, S as withDefault, T as num, _ as mapEach, a as safeErrorPage, b as HttpClient, c as ConsoleEventRecorder, d as getBaseUrl, f as removeHost, g as isSome, h as isNone, i as rewrite, k as makeSchema, l as CompositeEventRecorder, m as removeScheme, n as next, o as WithFieldsRecorder, p as removeQueryParams, r as redirect, s as VoidEventRecorder, t as deny, u as buildUrl, v as pipe, w as int, x as optional, y as pipeAsync } from "./types-BuaZHRG7.mjs";
+import { i as HttpError, n as classifyUrl, r as HostGuardError, t as classifyHost } from "./host-guard-DDWxLpFL.mjs";
+import { n as ExecutionError, r as executionErrorFromHttp, t as compilePath } from "./path-CGFl2w7D.mjs";
+import { a as isPublicMarked, i as getPublicFields, n as BASE_PAGE_FIELDS, o as markPublic, r as FINESOFT_PUBLIC, s as BaseController, t as resolveConfiguredMessages } from "./messages-CAt2QdGr.mjs";
+import { t as LruMap } from "./lru-map-BKoUAySU.mjs";
+import { n as createToken, t as DEP_KEYS } from "./src-Ftl_0rhu.mjs";
+export { ACTION_KINDS, ActionDispatcher, BASE_PAGE_FIELDS, BaseController, CompositeEventRecorder, CompositeLogger, CompositeLoggerFactory, ConsoleEventRecorder, ConsoleLogger, ConsoleLoggerFactory, Container, DEFAULT_NAV_PARAM, DEP_KEYS, ExecutionError, FINESOFT_PUBLIC, FRAMEWORK_PROTOCOL_VERSION, HostGuardError, HttpClient, HttpError, LruMap, NAVIGATION_NODE_KINDS, NavigationCommitError, NavigationError, PrefetchedIntents, ReportingLogger, ReportingLoggerFactory, Router, SERVER_CONTROLLER, SERVER_CONTROLLER_PATH, SERVER_REQUEST, SESSION_DEFAULT_KEY, SESSION_DEFAULT_VERSION, SPLIT_VISIBILITIES, ServerControllerProxy, SessionError, SimpleTranslator, StorageUnavailableError, VoidEventRecorder, WithFieldsRecorder, bool, buildUrl, classifyHost, classifyUrl, collectAllLeaves, collectLeafKeys, collectVisibleDestinations, compilePath, controllerContext, createActiveLeafCodec, createFullStateCodec, createNavigationScopedState, createRuntime, createSessionStore, createToken, createWebRuntime, createWebSession, decodeNavigationTreeParam, decodeSnapshot, decodeWireEnvelope, defineApp, defineModule, defineOperation, definePage, defineWebApp, deny, deserializeNavigation, detectPlatform, encodeNavigationTreeParam, encodeSnapshot, enforceHostGuard, englishPlural, executionErrorFromHttp, fetchWithRedirects, findNearestStack, findNode, generateUuid, getBaseUrl, getFrameworkBuildId, getLocaleAttributes, getPublicFields, getTextDirection, getWebPlan, implementController, implementOperation, int, interpolate, isCompoundAction, isExternalUrlAction, isFlowAction, isLeafNode, isMultiValueSchema, isNone, isPublicMarked, isRtl, isSome, isSplitNode, isStackNode, isTabsNode, leaf, list, loadPage, makeExternalUrlAction, makeFlowAction, makeLocaleInfo, makeSchema, mapEach, mapNavigationLeaves, markPublic, next, num, oneOf, optional, parseCookieString, pipe, pipeAsync, pop, popTo, popToRoot, provide, push, redirect, removeHost, removeQueryParams, removeScheme, replaceTop, resolveActivePath, resolveConfiguredMessages, resolveInitialNavigation, resolveLocaleFromUrl, resolveMessages, resolvePluralKey, resourceKey, rewrite, route, runAfterLoadGuards, runBeforeLoadGuards, safeErrorPage, secureFetch, selectColumn, selectTab, serializeNavigation, serializeNavigationStable, setVisibility, split, stableStringify, stack, str, tabs, uuid, visibleSplitColumns, withDefault };

package/dist/worker.d.mts

@@ -0,0 +1,2 @@
+import { a as HttpHost, i as HttpHandlerOptions, l as runManagedTask, o as ManagedTask, r as HttpHandler, s as createHttpHandler } from "./http-B6CJqDyf.mjs";
+export { type HttpHandler, type HttpHandlerOptions, type HttpHost, type ManagedTask, createHttpHandler, runManagedTask };

package/dist/worker.mjs

@@ -0,0 +1,2 @@
+import { r as runManagedTask, t as createHttpHandler } from "./http-D70PL72H.mjs";
+export { createHttpHandler, runManagedTask };

package/docs/01-getting-started.md

@@ -1,230 +1,98 @@
-# 1. Getting started
+# Getting started
 
-A working `@finesoft/front` app in five minutes. By the end you have a Vue/React/Svelte page rendering on the server, hydrating in the browser, and ready to deploy.
+All framework APIs use `from "@finesoft/front"`. The application creates one native React, Vue or Svelte root; its layout and providers surround Outlet. All six templates use this same model.
 
-## Prerequisites
-
-- Node.js `>= 22.12.0`
-- A package manager: pnpm (recommended), npm, or yarn
-- A view layer (Vue 3, React 19, or Svelte 5) — these docs use Vue, but every example translates one-to-one
-
-## Scaffold a new app
-
-```bash
-npx @finesoft/create-app my-app
-cd my-app
-pnpm install
-pnpm dev
-```
-
-The scaffolder generates a runnable app with routing, SSR, and proxy already wired. Open <http://localhost:5173>.
-
-If you want to understand what was generated, the rest of this page builds the same setup from scratch.
-
-## Add to an existing project
+Install dependencies first. Node must satisfy `^22.18.0 || >=24.11.0`; use Vite+ for project tooling. Full demonstrates products, search and guards; minimal demonstrates tabs/stacks, drafts and session restoration.
 
 ```bash
-pnpm add @finesoft/front
-pnpm add -D vite hono
+vp dlx @finesoft/create-app my-app
+vp install
 ```
 
-Peer dependencies: `hono >= 4.0.0`. Optional but recommended: `@hono/node-server` for Node deployment, `vite >= 5.0.0` for the dev server.
-
-## Minimal project layout
-
-```
-my-app/
-├── src/
-│   ├── bootstrap.ts       # routes + controllers (shared SSR + CSR)
-│   ├── main.ts            # browser entry
-│   ├── ssr.ts             # SSR entry
-│   ├── App.vue            # root component
-│   └── lib/
-│       └── controllers/
-│           └── home.ts
-├── index.html
-├── vite.config.ts
-├── package.json
-└── tsconfig.json
-```
-
-## Vite config
+## Page and route
 
 ```ts
-// vite.config.ts
-import { finesoftFrontViteConfig } from "@finesoft/front";
-import vue from "@vitejs/plugin-vue";
-import { defineConfig } from "vite";
-
-export default defineConfig({
-    plugins: [
-        vue(),
-        finesoftFrontViteConfig({
-            ssr: { entry: "src/ssr.ts" },
-            i18n: { messagesDir: "src/locales" },
-            adapter: "auto",
-        }),
-    ],
+// src/app-definition.ts
+import { definePage, defineWebApp, markPublic } from "@finesoft/front";
+export const home = definePage({
+    id: "home",
+    routes: ["/"],
+    handler: () => markPublic({ id: "home", pageType: "home" as const, title: "Home" }, []),
+});
+export const app = defineWebApp({
+    id: "example",
+    pages: [home],
+    getErrorPage: (status, title) => ({ id: String(status), pageType: "error", title }),
 });
 ```
 
-What `finesoftFrontViteConfig` adds:
-
-- A Hono-based dev server that runs your SSR entry on every request
-- Locale JSON auto-loading from `messagesDir`
-- A build pipeline that emits both the client bundle and a server entry
-- Platform adapter wiring for `adapter: "auto" | "node" | "vercel" | "cloudflare" | "netlify" | "static"`
-
-## Bootstrap (shared by SSR and CSR)
-
-```ts
-// src/bootstrap.ts
-import { type Framework, defineRoutes } from "@finesoft/front";
-import { HomeController } from "./lib/controllers/home";
-
-export function bootstrap(framework: Framework): void {
-    defineRoutes(framework, [{ path: "/", intentId: "home", controller: new HomeController() }]);
+## Native application root
+
+```tsx
+// src/App.tsx
+import { Outlet as selectOutlet, type WebAppView } from "@finesoft/front";
+import Home from "./pages/Home";
+import ErrorPage from "./pages/ErrorPage";
+const Outlet = selectOutlet("react");
+const views = { home: Home, error: ErrorPage };
+export default function App({ app }: { app: WebAppView }) {
+    return (
+        <div className="layout">
+            <Outlet app={app} views={views} />
+        </div>
+    );
 }
 ```
 
-The same `bootstrap()` runs on both sides. This is what guarantees the server and browser resolve URLs identically.
-
-## Controller
-
-```ts
-// src/lib/controllers/home.ts
-import { BaseController, type Container } from "@finesoft/front";
-
-interface HomePage {
-    kind: "home";
-    title: string;
-    items: string[];
-}
+Page components receive `{ page, app, entry }` and inherit native context from their layout. Real `<a href>` links use the same navigation flow; composed actions use `app.perform(action)`. Class-based loaders may use `BaseController.execute({ params, query, context })`.
 
-export class HomeController extends BaseController<Record<string, string>, HomePage> {
-    readonly intentId = "home";
-
-    async execute(_params: Record<string, string>, _container: Container): Promise<HomePage> {
-        return {
-            kind: "home",
-            title: "Welcome",
-            items: ["one", "two", "three"],
-        };
-    }
+## Browser entry
 
-    fallback(_params: Record<string, string>, error: unknown): HomePage {
-        return { kind: "home", title: "Failed", items: [] };
-    }
-}
+```tsx
+// src/main.tsx
+import { createBrowserApp } from "@finesoft/front";
+import { createRoot, hydrateRoot } from "react-dom/client";
+import { app as definition } from "./app-definition";
+import App from "./App";
+const target = document.getElementById("app")!;
+const app = await createBrowserApp({ definition, target });
+const root = app.shouldHydrate ? hydrateRoot(target, <App app={app} />) : createRoot(target);
+if (!app.shouldHydrate) root.render(<App app={app} />);
+await app.ready;
+// Cleanup owned by the application:
+// try { await app.dispose(); } finally { root.unmount(); }
 ```
 
-`BaseController` wraps `execute()` in `try/catch` and calls `fallback()` on error. Always provide a `fallback` — see [error handling](./08-observability.md#error-handling-via-fallback) for why.
+`createBrowserApp` returns a session ready to mount. Mount first, then await `ready`. Outlet acknowledges the native commit before session restoration starts. Awaiting ready before mounting would deadlock.
 
-## SSR entry
-
-```ts
-// src/ssr.ts
-import { createSSRRender, serializeServerData } from "@finesoft/front";
-import { createSSRApp } from "vue";
-import { renderToString } from "vue/server-renderer";
-import App from "./App.vue";
-import { bootstrap } from "./bootstrap";
+## SSR
 
+```tsx
+// src/ssr.tsx
+import { renderToString } from "react-dom/server";
+import { createSSRRender } from "@finesoft/front";
+import { app as definition } from "./app-definition";
+import App from "./App";
 export const render = createSSRRender({
-    bootstrap,
-    getErrorPage: () => ({ kind: "error", title: "Error" }),
-    async renderApp(page) {
-        const html = await renderToString(createSSRApp(App, { page }));
-        return { html, head: `<title>${(page as { title: string }).title}</title>`, css: "" };
-    },
+    definition,
+    render: (app) => renderToString(<App app={app} />),
 });
-
-export { serializeServerData };
+export { serializeServerData } from "@finesoft/front";
 ```
 
-`createSSRRender` returns a function that takes a URL and returns rendered HTML + serialized prefetched intent data. The Vite plugin and adapters call it for you — you do not invoke it directly.
-
-## Browser entry
+## Vite
 
 ```ts
-// src/main.ts
-import { startBrowserApp } from "@finesoft/front/browser";
-import { createSSRApp } from "vue";
-import App from "./App.vue";
-import { bootstrap } from "./bootstrap";
-
-startBrowserApp({
-    bootstrap,
-    mount(target, { framework }) {
-        const app = createSSRApp(App, { framework });
-        app.mount(target);
-    },
+import { defineConfig } from "vite-plus";
+import react from "@vitejs/plugin-react";
+import { finesoftFrontViteConfig } from "@finesoft/front";
+export default defineConfig({
+    plugins: [react(), finesoftFrontViteConfig({ adapter: "node", ssr: { entry: "src/ssr.tsx" } })],
 });
 ```
 
-`startBrowserApp` reads the SSR-injected `PrefetchedIntents` from the DOM, creates the `Framework`, runs the same `bootstrap()` as the server, and triggers the first page. By the time `mount()` runs the framework already has the initial `Page` ready.
-
-Import from `@finesoft/front/browser` (not `@finesoft/front`) on the client to avoid pulling server-only modules into your client bundle.
-
-## Root component (Vue example)
-
-```vue
-<!-- src/App.vue -->
-<script setup lang="ts">
-import { computed } from "vue";
-import type { Framework } from "@finesoft/front";
-
-const props = defineProps<{ framework?: Framework; page?: { title: string; items: string[] } }>();
-
-// SSR receives `page` directly; CSR pulls the current page from the framework.
-const page = computed(() => props.page ?? props.framework?.getCurrentPage());
-</script>
-
-<template>
-    <main>
-        <h1>{{ page?.title }}</h1>
-        <ul>
-            <li v-for="item in page?.items" :key="item">{{ item }}</li>
-        </ul>
-    </main>
-</template>
-```
-
-## index.html
-
-```html
-<!doctype html>
-<html lang="en">
-    <head>
-        <meta charset="UTF-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-        <!--head-->
-    </head>
-    <body>
-        <div id="app"><!--ssr--></div>
-        <script type="module" src="/src/main.ts"></script>
-    </body>
-</html>
-```
-
-The `<!--head-->` and `<!--ssr-->` placeholders are where the framework injects the SSR head fragment and rendered HTML. The placeholder names are exported as `SSR_PLACEHOLDERS` if you need them.
-
-## Run it
-
-```bash
-pnpm dev          # development with HMR
-pnpm build        # production build
-pnpm preview      # serve the production build locally
-```
-
-Done. You have an app that:
-
-- Renders on the server with prefetched data
-- Hydrates without an extra fetch (SSR data is reused via `PrefetchedIntents`)
-- Routes client-side without page reloads
-- Is ready to deploy to any of the supported adapters
+Vue selects `Outlet("vue")` and uses `createSSRApp` / `createApp` with `renderToString`. Svelte selects `Outlet("svelte")` and uses `hydrate` / `mount` with `render` from `svelte/server`. See the matching templates. Before a fresh Svelte `mount`, clear the target when `hydrate` is false so rejected SSR markup cannot remain beside the new app.
 
-## Next
+`useSnapshot("react", app)` returns a snapshot, `useSnapshot("vue", app)` a native ref, and `useSnapshot("svelte", app)` a store. Use a string literal for the renderer. The Vite plugin resolves the selected native implementation at build time, preserving component identity, subscriptions and cleanup.
 
-- [Routing & controllers](./02-routing-and-controllers.md) — define more routes and control how they render
-- [Project structure](./engineering/project-structure.md) — recommended layout once the app grows past a handful of pages
+On initialization the plugin generates `.finesoft/front.d.ts` and maintains the exact `@finesoft/front` type path in `tsconfig.json`. Only the selected UI peers are required. Ignore `.finesoft/` in Git and restart development after dependency changes. For standalone `tsc` or Node projects, run `vp exec finesoft-types` first, or call `generateFrontTypes({ root })` from the unified entry. The alias affects types only; runtime imports resolve the published package.