@lotics/app-sdk 0.100.0 → 0.101.0

package/dist/src/new_record.js

@@ -1,117 +0,0 @@
-import { useCallback, useEffect, useRef } from "react";
-const ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-const ID_LENGTH = 12;
-/**
- * Mint a record id locally, in the shape the platform mints.
- *
- * The generator is restated here rather than imported because the canonical one
- * lives in a package that is not published, and this one is. The duplication is
- * safe by construction rather than by discipline: the server validates the shape on
- * every write, so a client that drifted would be rejected loudly at the first call
- * instead of quietly persisting a malformed primary key.
- *
- * Uses `crypto.getRandomValues` — available in every browser this SDK runs in — and
- * rejection-samples so each character is uniformly drawn from the alphabet. A plain
- * `% 62` over bytes would bias the first 8 characters, which is a poor property for
- * something used as a primary key.
- */
-export function newRecordId() {
-    const max = 256 - (256 % ID_ALPHABET.length);
-    let out = "";
-    const buf = new Uint8Array(ID_LENGTH * 2);
-    while (out.length < ID_LENGTH) {
-        crypto.getRandomValues(buf);
-        for (let i = 0; i < buf.length && out.length < ID_LENGTH; i++) {
-            if (buf[i] < max)
-                out += ID_ALPHABET[buf[i] % ID_ALPHABET.length];
-        }
-    }
-    return `rec_${out}`;
-}
-/**
- * A record that does not exist yet, named before it does.
- *
- * The problem this removes: when the server mints the id, a surface editing a new
- * record has nothing to identify it by until the first write returns. Everything
- * keyed on that id — the route, the drawer, a list selection — therefore changes
- * identity mid-edit, which React resolves by remounting the surface the user is
- * typing into. Minting the id locally makes it stable from the first render, so the
- * create stops being an event the UI has to survive.
- *
- * Creation still happens on the first write, not on mount: a surface the user opens
- * and abandons should leave nothing behind.
- *
- * The transport is the caller's. Like `useOptimistic`, this hook has no idea how the
- * app persists anything — it takes `create` and `update` thunks and owns only the id
- * and the ordering, which is the part that is easy to get wrong:
- *
- * - Two blur-saves fired before the first resolves must not both create. That is a
- *   duplicate record, and it is the failure this exists to prevent.
- * - A save arriving mid-create must wait for it, or it updates a row that is not
- *   there yet.
- * - A create that FAILS must not latch. Otherwise every later save updates a record
- *   that was never written, and the user's work goes nowhere while looking saved.
- *
- * ```tsx
- * const { id, save } = useNewRecord({
- *   create: (id, patch) => createCustomer({ record_id: id, ...patch }),
- *   update: (id, patch) => updateCustomer({ record_id: id, ...patch }),
- *   onCreated: (id) => select(id),   // it exists now — the list re-reads itself
- * });
- * <InlineText onBlur={(name) => save({ name })} />
- * ```
- */
-export function useNewRecord(opts) {
-    const idRef = useRef("");
-    if (idRef.current === "")
-        idRef.current = newRecordId();
-    // Callbacks are read through a ref so `save` keeps a stable identity across
-    // renders — it is typically handed to an `onBlur`, and a new function every render
-    // would re-bind every field on every keystroke.
-    //
-    // Updated in an effect rather than during render: React only sanctions writing a
-    // ref while rendering for one-time initialisation (as `idRef` above does), because
-    // a render that is discarded would otherwise leave the ref holding props that never
-    // committed. `save` runs from event handlers, which are always after commit, so the
-    // effect is early enough.
-    const optsRef = useRef(opts);
-    useEffect(() => {
-        optsRef.current = opts;
-    });
-    /** The in-flight or settled create. `null` means the record does not exist yet. */
-    const createdRef = useRef(null);
-    /** Tail of the write chain, so saves apply in the order the user made them. */
-    const queueRef = useRef(Promise.resolve());
-    const save = useCallback((patch) => {
-        const run = async () => {
-            const id = idRef.current;
-            const { create, update, onCreated } = optsRef.current;
-            if (createdRef.current === null) {
-                const attempt = (async () => {
-                    await create(id, patch);
-                })();
-                createdRef.current = attempt;
-                try {
-                    await attempt;
-                }
-                catch (error) {
-                    // Unlatch. The record was not written, so the next save has to be free to
-                    // create it — leaving the promise in place would send every later write to
-                    // a row that does not exist.
-                    createdRef.current = null;
-                    throw error;
-                }
-                onCreated?.(id);
-                return;
-            }
-            await createdRef.current;
-            await update(id, patch);
-        };
-        // Chained on both settle paths: one failed save must not strand the ones behind
-        // it, but they still have to run in order.
-        const result = queueRef.current.then(run, run);
-        queueRef.current = result.catch(() => undefined);
-        return result;
-    }, []);
-    return { id: idRef.current, save };
-}

package/dist/src/open_app.d.ts

@@ -1,15 +0,0 @@
-/**
- * Open a record's screen in the sibling app that owns it — the cross-app hop.
- * The host owns app routing and lands the viewer on `route` inside `appId`,
- * same tab, chrome kept. `route` is the target app's own in-app path, exactly
- * as its router declares it (`/` for its register).
- *
- * ```tsx
- * import { openApp } from "@lotics/app-sdk";
- * await openApp(PLANNING_APP_ID, `/plan/${record.id}`);
- * ```
- *
- * Standalone (`<slug>.lotics.app`) has no sibling apps, so the call rejects
- * there — gate the control on `isEmbedded()`.
- */
-export declare function openApp(appId: string, route?: string): Promise<void>;

package/dist/src/open_app.js

@@ -1,18 +0,0 @@
-import { rpc } from "./rpc.js";
-/**
- * Open a record's screen in the sibling app that owns it — the cross-app hop.
- * The host owns app routing and lands the viewer on `route` inside `appId`,
- * same tab, chrome kept. `route` is the target app's own in-app path, exactly
- * as its router declares it (`/` for its register).
- *
- * ```tsx
- * import { openApp } from "@lotics/app-sdk";
- * await openApp(PLANNING_APP_ID, `/plan/${record.id}`);
- * ```
- *
- * Standalone (`<slug>.lotics.app`) has no sibling apps, so the call rejects
- * there — gate the control on `isEmbedded()`.
- */
-export function openApp(appId, route = "/") {
-    return rpc("openApp", { app_id: appId, route });
-}

package/dist/src/open_external.d.ts

@@ -1,16 +0,0 @@
-/**
- * Open an external URL in a new tab.
- *
- * The embedded app iframe is sandboxed without `allow-popups`, so a direct
- * `window.open` from app code is silently dropped. This routes the open to
- * whoever can actually perform it: the un-sandboxed host frame (embedded) or
- * the app's own top-level page (public). The URL is scheme-validated
- * (`http`/`https` only) at the point it opens — a non-string or disallowed
- * scheme rejects.
- *
- * ```tsx
- * import { openExternal } from "@lotics/app-sdk";
- * await openExternal(invoiceUrl);
- * ```
- */
-export declare function openExternal(url: string): Promise<void>;

package/dist/src/open_external.js

@@ -1,19 +0,0 @@
-import { rpc } from "./rpc.js";
-/**
- * Open an external URL in a new tab.
- *
- * The embedded app iframe is sandboxed without `allow-popups`, so a direct
- * `window.open` from app code is silently dropped. This routes the open to
- * whoever can actually perform it: the un-sandboxed host frame (embedded) or
- * the app's own top-level page (public). The URL is scheme-validated
- * (`http`/`https` only) at the point it opens — a non-string or disallowed
- * scheme rejects.
- *
- * ```tsx
- * import { openExternal } from "@lotics/app-sdk";
- * await openExternal(invoiceUrl);
- * ```
- */
-export function openExternal(url) {
-    return rpc("openExternal", { url });
-}

package/dist/src/recording.d.ts

@@ -1,59 +0,0 @@
-import { type RecordingState } from "./recording_state.js";
-import type { AppWorkflows } from "./types.js";
-/** The platform fills a receiving workflow's `recording` input; the app passes
- *  the rest of what the workflow declares. */
-type ActInputsOf<K extends keyof AppWorkflows & string> = AppWorkflows[K] extends Record<string, unknown> ? Omit<AppWorkflows[K], "recording"> : Record<string, unknown>;
-export interface UseRecording<I> {
-    /**
-     * Whether this surface can record. False standalone, in a host that
-     * predates recording, on an instance without transcription, and until the
-     * host's context has answered. A control that starts a recording is drawn
-     * only when this is true.
-     */
-    available: boolean;
-    /** The most recent recording this app started through this alias. */
-    state: RecordingState;
-    /** Whether a recording this app started is live, through any alias. The
-     *  host records one at a time, so a start while this is true is refused. */
-    busy: boolean;
-    /**
-     * Ask the host to record. The host opens its own capture dialog, and nothing
-     * records until the member presses Start there. Resolves `{ started: true }`
-     * once capture runs, `{ started: false }` when the member closed the dialog;
-     * rejects, with the reason, when the host refuses (another recording is
-     * running, the inputs fail the workflow's contract, recording is unavailable).
-     * When the recording is transcribed, the host runs the alias's workflow with
-     * these inputs plus `recording`.
-     */
-    start: {} extends I ? (inputs?: I) => Promise<{
-        started: boolean;
-    }> : (inputs: I) => Promise<{
-        started: boolean;
-    }>;
-    /** Stop this alias's live recording. Resolves whether or not one was live. */
-    stop: () => Promise<void>;
-}
-/**
- * Record a call, a visit, a meeting — and file it through a workflow.
- *
- * `alias` names a workflow that declares the platform's `recording` input; the
- * host records as the signed-in member and, once the transcript is ready, runs
- * that workflow once with the app's inputs and the recording. Its write reaches
- * the screen like any workflow's.
- *
- * ```tsx
- * const visit = useRecording("log_visit");
- * if (!visit.available) return null;
- * if (visit.state.phase === "live" && visit.state.inputs.site === siteId) {
- *   return <Button onPress={() => visit.stop()}>Stop</Button>;
- * }
- * return (
- *   <Button disabled={visit.busy} onPress={() => visit.start({ site: siteId })}>
- *     Record the visit
- *   </Button>
- * );
- * ```
- */
-export declare function useRecording<K extends keyof AppWorkflows & string>(alias: K): UseRecording<ActInputsOf<K>>;
-export declare function useRecording(alias: string): UseRecording<Record<string, unknown>>;
-export {};

package/dist/src/recording.js

@@ -1,30 +0,0 @@
-import { useCallback, useSyncExternalStore } from "react";
-import { rpc } from "./rpc.js";
-import { getMockRecordings } from "./mock.js";
-import { useAppContext } from "./viewer.js";
-import { anyRecordingLive, recordingStateOf, subscribeRecordings, } from "./recording_state.js";
-const NO_MOCKS = {};
-export function useRecording(alias) {
-    const { recordingEnabled } = useAppContext();
-    const mocks = getMockRecordings() ?? NO_MOCKS;
-    const mocked = mocks[alias];
-    const hostState = useSyncExternalStore(subscribeRecordings, () => recordingStateOf(alias));
-    const hostBusy = useSyncExternalStore(subscribeRecordings, anyRecordingLive);
-    const start = useCallback(async (inputs) => {
-        if (getMockRecordings()?.[alias])
-            return { started: true };
-        return rpc("recording.start", { alias, inputs: inputs ?? {} });
-    }, [alias]);
-    const stop = useCallback(async () => {
-        if (getMockRecordings()?.[alias])
-            return;
-        await rpc("recording.stop", { alias });
-    }, [alias]);
-    return {
-        available: mocked !== undefined || recordingEnabled,
-        state: mocked ?? hostState,
-        busy: hostBusy || Object.values(mocks).some((state) => state.phase === "live"),
-        start,
-        stop,
-    };
-}

package/dist/src/recording_state.d.ts

@@ -1,59 +0,0 @@
-/**
- * What the host says about the recordings THIS app started, one per workflow
- * alias: the most recently started recording through that alias.
- *
- * A leaf module, because two sides write it and one reads it: the bridge
- * listener in `rpc.ts` applies the host's `recordingChanged` push, the context
- * fetch in `viewer.ts` applies the snapshot a newly loaded frame starts from,
- * and `useRecording` reads it. Both writes arrive on the one postMessage channel
- * in the order the host sent them, so the later arrival is always the newer
- * state.
- */
-/** The act's own inputs the recording was started with — what `start` was
- *  passed, echoed back so a screen drawing one act per row can tell which row
- *  the recording is about. */
-export type RecordingInputs = Record<string, unknown>;
-/**
- * One recording, from the host's side. `idle`: nothing of this alias's is
- * running or waiting. `live`: capturing. `interrupted`: the tab closed mid-call
- * and the member has not yet resumed or finished it from the recording bar.
- * `processing`: stopped, the transcript is on its way. `filed`: the workflow
- * ran and succeeded. `failed`: transcription failed, the platform refused to
- * file (the member lost access, the alias or its declaration changed), or the
- * run failed; the recording is kept, and the member retries from the recording
- * bar.
- */
-export type RecordingState = {
-    phase: "idle";
-} | {
-    phase: "live";
-    elapsed_seconds: number;
-    inputs: RecordingInputs;
-} | {
-    phase: "interrupted";
-    elapsed_seconds: number;
-    inputs: RecordingInputs;
-} | {
-    phase: "processing";
-    inputs: RecordingInputs;
-} | {
-    phase: "filed";
-    execution_id: string;
-    inputs: RecordingInputs;
-} | {
-    phase: "failed";
-    message: string;
-    inputs: RecordingInputs;
-};
-export declare const IDLE_RECORDING: RecordingState;
-export declare function subscribeRecordings(listener: () => void): () => void;
-export declare function recordingStateOf(alias: string): RecordingState;
-export declare function anyRecordingLive(): boolean;
-/** The host's push for one alias. */
-export declare function applyRecordingChange(alias: string, state: RecordingState): void;
-/** The snapshot `context` carries: every alias it omits is idle. */
-export declare function replaceRecordings(snapshot: Record<string, RecordingState>): void;
-/** A host message's `state`, or null when it is not one. */
-export declare function readRecordingState(raw: unknown): RecordingState | null;
-/** A context's `recordings`, keeping each well-formed entry. */
-export declare function readRecordingSnapshot(raw: unknown): Record<string, RecordingState>;

package/dist/src/recording_state.js

@@ -1,94 +0,0 @@
-/**
- * What the host says about the recordings THIS app started, one per workflow
- * alias: the most recently started recording through that alias.
- *
- * A leaf module, because two sides write it and one reads it: the bridge
- * listener in `rpc.ts` applies the host's `recordingChanged` push, the context
- * fetch in `viewer.ts` applies the snapshot a newly loaded frame starts from,
- * and `useRecording` reads it. Both writes arrive on the one postMessage channel
- * in the order the host sent them, so the later arrival is always the newer
- * state.
- */
-export const IDLE_RECORDING = { phase: "idle" };
-const states = new Map();
-const listeners = new Set();
-function emit() {
-    for (const listener of listeners)
-        listener();
-}
-export function subscribeRecordings(listener) {
-    listeners.add(listener);
-    return () => {
-        listeners.delete(listener);
-    };
-}
-export function recordingStateOf(alias) {
-    return states.get(alias) ?? IDLE_RECORDING;
-}
-export function anyRecordingLive() {
-    for (const state of states.values())
-        if (state.phase === "live")
-            return true;
-    return false;
-}
-/** The host's push for one alias. */
-export function applyRecordingChange(alias, state) {
-    if (state.phase === "idle")
-        states.delete(alias);
-    else
-        states.set(alias, state);
-    emit();
-}
-/** The snapshot `context` carries: every alias it omits is idle. */
-export function replaceRecordings(snapshot) {
-    states.clear();
-    for (const [alias, state] of Object.entries(snapshot)) {
-        if (state.phase !== "idle")
-            states.set(alias, state);
-    }
-    emit();
-}
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/** A host message's `state`, or null when it is not one. */
-export function readRecordingState(raw) {
-    if (!isRecord(raw))
-        return null;
-    if (raw.phase === "idle")
-        return IDLE_RECORDING;
-    const inputs = raw.inputs;
-    if (!isRecord(inputs))
-        return null;
-    switch (raw.phase) {
-        case "live":
-        case "interrupted":
-            return typeof raw.elapsed_seconds === "number"
-                ? { phase: raw.phase, elapsed_seconds: raw.elapsed_seconds, inputs }
-                : null;
-        case "processing":
-            return { phase: "processing", inputs };
-        case "filed":
-            return typeof raw.execution_id === "string"
-                ? { phase: "filed", execution_id: raw.execution_id, inputs }
-                : null;
-        case "failed":
-            return typeof raw.message === "string" ? { phase: "failed", message: raw.message, inputs } : null;
-        default:
-            return null;
-    }
-}
-/** A context's `recordings`, keeping each well-formed entry. */
-export function readRecordingSnapshot(raw) {
-    if (!isRecord(raw))
-        return {};
-    const entries = Object.entries(raw).flatMap(([alias, value]) => {
-        const state = readRecordingState(value);
-        if (state === null) {
-            console.error(`The host's context carried a malformed recording for "${alias}"; it reads as idle.`, value);
-            return [];
-        }
-        return [[alias, state]];
-    });
-    return Object.fromEntries(entries);
-}

package/dist/src/router.d.ts

@@ -1,17 +0,0 @@
-import { type RouteObject } from "react-router";
-/**
- * The not-found screen's words. The SDK ships no locale, so an app whose reader
- * does not read English passes its own — from `@lotics/ui`'s locale where the app
- * uses the kit, from its own strings otherwise.
- */
-export interface NotFoundWords {
-    /** Names the address that has no screen. Takes the path so the words may put
-     *  it anywhere the language needs it. */
-    message: (path: string) => string;
-    /** The label of the link back to the first screen. */
-    firstScreen: string;
-}
-export declare function AppRouter({ routes, notFound }: {
-    routes: RouteObject[];
-    notFound?: NotFoundWords;
-}): import("react").JSX.Element;

package/dist/src/router.js

@@ -1,144 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * In-app routing for custom-code apps — `AppRouter` lets an app use react-router
- * normally (`useNavigate`, `useParams`, `<Link>`) while its screens become real,
- * addressable URLs. The app owns its OWN url (a plain browser history) in both
- * modes; the host url only ever *mirrors* the screen, it never drives the router:
- *
-  *  - **Standalone** (the app's own origin): the page's own browser history — real
- *    path URLs, native browser back/forward, deep-link/refresh via the app host's
- *    SPA fallback.
- *  - **Embedded** (inside the Lotics host): the app drives the IFRAME's own url
- *    (the iframe is same-origin to itself) via `pushState`. The user sees the
- *    host's address bar, never the iframe's, and the host never sees the iframe's
- *    url — so it never navigates and never remounts the iframe. (Reflecting the
- *    screen into the host url with a *navigation* is what used to remount the app
- *    iframe and reload the whole app on every in-app navigation.) The iframe's
- *    history still participates in the session history, so browser Back/Forward
- *    walk app screens (then leave the app).
- *
- *    To stay shareable + refresh-survivable, `AppRouter` *mirrors* the current
- *    screen into the host url under `_loc` via `setUrlParams` — a non-remounting
- *    `history.replaceState` on the host, never a navigation. The READ half is the
- *    host's job: on (re)load it bakes `_loc` into the iframe src, so the app boots
- *    *directly* at the saved screen. There's deliberately no async seed here —
- *    that would race the app's own first navigation; the iframe's initial url is
- *    the source of truth, set synchronously by the host.
- *
- * Shipped as a separate entry (`@lotics/app-sdk/router`) so apps that don't route
- * never pull react-router into their bundle:
- *
- *   import { AppRouter } from "@lotics/app-sdk/router";
- *   export default function App() {
- *     return <AppRouter routes={[
- *       { path: "/", element: <List /> },
- *       { path: "/item/:id", element: <Detail /> },
- *     ]} />;
- *   }
- *
- * An address none of the routes claim renders the SDK's not-found screen rather
- * than nothing — see {@link NotFoundScreen} and {@link withNotFound}. Its words
- * are the `notFound` prop ({@link NotFoundWords}), because an app's reader reads
- * the app's language and the SDK ships no locale.
- */
-import { useEffect } from "react";
-import { BrowserRouter, Link, useLocation, useRoutes, } from "react-router";
-import { isEmbedded, setUrlParams } from "./rpc.js";
-/** Host query key carrying the app's current screen, so it's shareable and the
- *  host can restore it on refresh. */
-const LOC_KEY = "_loc";
-/** The host handshake param the host puts on the iframe src — present on the
- *  initial url only, never part of a route, so it's stripped from the mirror. */
-const HOST_KEY = "lotics_host";
-function screenHref(loc) {
-    const search = new URLSearchParams(loc.search);
-    search.delete(HOST_KEY);
-    const qs = search.toString();
-    return loc.pathname + (qs ? `?${qs}` : "") + loc.hash;
-}
-/**
- * Embedded only: mirror the current screen into the host url under `_loc` — a
- * non-remounting `setUrlParams` → `history.replaceState`, never a navigation, so
- * it never reloads the app. Write-only by design: the host reads `_loc` back and
- * bakes it into the iframe src on (re)load, so the app already boots at the saved
- * screen — no async read here, hence no seed-vs-navigation race. Standalone needs
- * none of this — the app's own url already IS the screen.
- */
-function HostScreenMirror() {
-    const location = useLocation();
-    const href = screenHref(location);
-    useEffect(() => {
-        void setUrlParams({ [LOC_KEY]: href });
-    }, [href]);
-    return null;
-}
-function RoutedRoutes({ routes }) {
-    return useRoutes(routes);
-}
-/*
- * Shaped like the kit's `RegionState` — a centred message and one destination —
- * and written in its tokens with literal fallbacks, so it takes the app's theme
- * where `@lotics/ui/styles.css` is loaded and stays legible where it is not. It
- * cannot BE `RegionState`: the SDK ships no kit component.
- */
-const NOT_FOUND_ROOT = {
-    display: "flex",
-    flexDirection: "column",
-    alignItems: "center",
-    justifyContent: "center",
-    gap: "var(--lotics-space-8, 8px)",
-    paddingBlock: "var(--lotics-space-48, 48px)",
-    paddingInline: "var(--lotics-space-16, 16px)",
-    textAlign: "center",
-    fontFamily: "var(--font-sans, system-ui, sans-serif)",
-};
-const NOT_FOUND_MESSAGE = {
-    margin: 0,
-    fontSize: "var(--lotics-text-sm, 14px)",
-    color: "var(--lotics-ink-muted, #71717a)",
-};
-const NOT_FOUND_LINK = {
-    fontSize: "var(--lotics-text-sm, 14px)",
-    color: "var(--lotics-accent, #2563eb)",
-};
-const NOT_FOUND_ENGLISH = {
-    message: (path) => `No screen at ${path}`,
-    firstScreen: "Go to the first screen",
-};
-/**
- * What an app shows at an address none of its routes claim. Without it
- * `useRoutes` matches nothing and the page renders EMPTY — no message and no
- * console error — so a stale link or a typo reads as a crash.
- */
-function NotFoundScreen({ home, words }) {
-    const { pathname } = useLocation();
-    return (_jsxs("div", { style: NOT_FOUND_ROOT, children: [
-            _jsx("p", { style: NOT_FOUND_MESSAGE, children: words.message(pathname) }), _jsx(Link, { to: home, style: NOT_FOUND_LINK, children: words.firstScreen })
-        ] }));
-}
-/**
- * The catch-all, appended at EVERY level of the tree: a route with `children`
- * is a layout, and a catch-all among those children is what keeps that layout's
- * shell on screen instead of swapping the whole page for the message. An app
- * that declares its own `*` still wins — react-router ranks equal matches by
- * declaration order and ours is appended last.
- */
-function withNotFound(routes, element) {
-    return [
-        ...routes.map((route) => route.children === undefined
-            ? route
-            : { ...route, children: withNotFound(route.children, element) }),
-        { path: "*", element },
-    ];
-}
-/** The screen the not-found sends the reader back to — the first one declared. */
-function firstScreenPath(routes) {
-    const first = routes.find((route) => route.path !== undefined && route.path !== "*");
-    return first?.path ?? "/";
-}
-export function AppRouter({ routes, notFound = NOT_FOUND_ENGLISH, }) {
-    // `isEmbedded()` reads the `?lotics_host=` the host puts on the iframe src, so
-    // it's known synchronously at first render.
-    const embedded = isEmbedded();
-    return (_jsxs(BrowserRouter, { children: [embedded ? _jsx(HostScreenMirror, {}) : null, _jsx(RoutedRoutes, { routes: withNotFound(routes, _jsx(NotFoundScreen, { home: firstScreenPath(routes), words: notFound })) })] }));
-}